falkordb 6.5.1 → 6.6.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { default as Graph } from './src/graph';
 export { ConstraintType, EntityType } from './src/graph';
-export { default as FalkorDB, FalkorDBOptions } from './src/falkordb';
+export { default as FalkorDB } from './src/falkordb';
+export type { FalkorDBOptions } from './src/falkordb';

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

@@ -1,4 +1,4 @@
-import { RedisCommandArgument } from "@redis/client/dist/lib/commands";
+import { RedisArgument } from "@redis/client";
 import { QueryOptions } from "../commands";
 import { ConstraintType, EntityType } from "../graph";
 import FalkorDB from "../falkordb";
@@ -11,9 +11,9 @@ export interface Client {
     configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
     configSet(configKey: string, value: number | string): Promise<void>;
     info(section?: string): Promise<(string | string[])[]>;
-    query<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<any>;
-    profile<T>(graph: string, query: RedisCommandArgument): Promise<any>;
-    roQuery<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<any>;
+    query<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<any>;
+    profile<T>(graph: string, query: RedisArgument): Promise<any>;
+    roQuery<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<any>;
     copy<T>(srcGraph: string, destGraph: string): Promise<any>;
     delete(graph: string): Promise<void>;
     explain(graph: string, query: string): Promise<any>;

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

@@ -1,6 +1,6 @@
 import { Client } from "./client";
 import { ConstraintType, EntityType } from "../graph";
-import { RedisCommandArgument, RedisFunctions, RedisScripts } from "@redis/client/dist/lib/commands";
+import { RedisArgument, RedisFunctions, RedisScripts } from "@redis/client";
 import commands, { QueryOptions } from "../commands";
 import { RedisClusterType } from "@redis/client";
 import FalkorDB from "../falkordb";
@@ -9,7 +9,7 @@ import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
 import { UdfListReply } from "../commands/UDF_LIST";
 export type ClusterGraphConnection = RedisClusterType<{
     falkordb: typeof commands;
-}, RedisFunctions, RedisScripts>;
+}, RedisFunctions, RedisScripts, 2>;
 /**
  * A client that connects to a Redis Cluster.
  */
@@ -18,9 +18,9 @@ export declare class Cluster implements Client {
     constructor(client: SingleGraphConnection);
     getConnection(): Promise<import("@redis/client").RedisClientType<{
         falkordb: typeof commands;
-    }, RedisFunctions, RedisScripts>>;
+    }, RedisFunctions, RedisScripts, 2, {}>>;
     init(falkordb: FalkorDB): Promise<void>;
-    query<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<{
+    query<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -29,7 +29,7 @@ export declare class Cluster implements Client {
         data: (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)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[];
         metadata: string[];
     }>;
-    roQuery<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<{
+    roQuery<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -39,7 +39,7 @@ export declare class Cluster implements Client {
         metadata: string[];
     }>;
     delete(graph: string): Promise<void>;
-    explain(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>;
+    explain(graph: string, query: string): Promise<string[]>;
     list(): Promise<Array<string>>;
     configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
     configSet(configKey: string, value: number | string): Promise<void>;
@@ -58,7 +58,7 @@ export declare class Cluster implements Client {
     udfList(lib?: string, withCode?: boolean): Promise<UdfListReply>;
     udfFlush(): Promise<string>;
     udfDelete(lib: string): Promise<string>;
-    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>;
+    profile<_T>(graph: string, query: string): Promise<string[]>;
     quit(): Promise<void>;
     disconnect(): Promise<void>;
 }

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

@@ -1,4 +1,4 @@
-import { RedisCommandArgument } from "@redis/client/dist/lib/commands";
+import { RedisArgument } from "@redis/client";
 import { QueryOptions } from "../commands";
 import FalkorDB from "../falkordb";
 import { ConstraintType, EntityType } from "../graph";
@@ -24,9 +24,9 @@ export declare class NullClient implements Client {
     configGet(_configKey: string): Promise<(string | number)[] | (string | number)[][]>;
     configSet(_configKey: string, _value: number | string): Promise<void>;
     info(_section?: string): Promise<(string | string[])[]>;
-    query<_T>(_graph: string, _query: RedisCommandArgument, _options?: QueryOptions): Promise<any>;
-    profile<_T>(_graph: string, _query: RedisCommandArgument): Promise<any>;
-    roQuery<_T>(_graph: string, _query: RedisCommandArgument, _options?: QueryOptions): Promise<any>;
+    query<_T>(_graph: string, _query: RedisArgument, _options?: QueryOptions): Promise<any>;
+    profile<_T>(_graph: string, _query: RedisArgument): Promise<any>;
+    roQuery<_T>(_graph: string, _query: RedisArgument, _options?: QueryOptions): Promise<any>;
     copy<_T>(_srcGraph: string, _destGraph: string): Promise<any>;
     delete(_graph: string): Promise<void>;
     explain(_graph: string, _query: string): Promise<any>;

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

@@ -1,6 +1,6 @@
 import { Client } from "./client";
 import { ConstraintType, EntityType } from "../graph";
-import { RedisCommandArgument, RedisFunctions, RedisScripts } from "@redis/client/dist/lib/commands";
+import { RedisArgument, RedisFunctions, RedisScripts } from "@redis/client";
 import commands, { QueryOptions } from "../commands";
 import { RedisClientType } from "@redis/client";
 import FalkorDB from "../falkordb";
@@ -8,13 +8,12 @@ import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
 import { UdfListReply } from "../commands/UDF_LIST";
 export type SingleGraphConnection = RedisClientType<{
     falkordb: typeof commands;
-}, RedisFunctions, RedisScripts>;
+}, RedisFunctions, RedisScripts, 2>;
 export declare class Single implements Client {
-    #private;
     protected client: SingleGraphConnection;
     constructor(client: SingleGraphConnection);
     init(_falkordb: FalkorDB): Promise<void>;
-    query<_T>(graph: string, query: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<{
+    query<_T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -23,7 +22,7 @@ export declare class Single implements Client {
         data: (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)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[];
         metadata: string[];
     }>;
-    roQuery<_T>(graph: string, query: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<{
+    roQuery<_T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -33,8 +32,8 @@ export declare class Single implements Client {
         metadata: string[];
     }>;
     delete(graph: string): Promise<void>;
-    explain(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>;
-    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>;
+    explain(graph: string, query: string): Promise<string[]>;
+    profile<_T>(graph: string, query: string): Promise<string[]>;
     list(): Promise<string[]>;
     configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
     configSet(configKey: string, value: number | string): Promise<void>;

package/dist/src/clients/single.js

@@ -3,54 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Single = void 0;
 class Single {
     client;
-    #usePool;
     constructor(client) {
         this.client = client;
-        this.#usePool = !!this.client.options?.isolationPoolOptions;
     }
     init(_falkordb) {
         return Promise.resolve();
     }
     async query(graph, query, options, compact = true) {
-        const reply = this.#usePool
-            ? await this.client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.query(graph, query, options, compact);
-            })
-            : await this.client.falkordb.query(graph, query, options, compact);
-        return reply;
+        return await this.client.falkordb.query(graph, query, options, compact);
     }
     async roQuery(graph, query, options, compact = true) {
-        const reply = this.#usePool
-            ? await this.client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.roQuery(graph, query, options, compact);
-            })
-            : await this.client.falkordb.roQuery(graph, query, options, compact);
-        return reply;
+        return await this.client.falkordb.roQuery(graph, query, options, compact);
     }
     async delete(graph) {
-        if (this.#usePool) {
-            return this.client.executeIsolated(async (isolatedClient) => {
-                const reply = isolatedClient.falkordb.delete(graph);
-                return reply.then(() => { });
-            });
-        }
         const reply = this.client.falkordb.delete(graph);
         return reply.then(() => { });
     }
     async explain(graph, query) {
-        if (this.#usePool) {
-            return this.client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.explain(graph, query);
-            });
-        }
         return this.client.falkordb.explain(graph, query);
     }
     async profile(graph, query) {
-        if (this.#usePool) {
-            return this.client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.profile(graph, query);
-            });
-        }
         return this.client.falkordb.profile(graph, query);
     }
     async list() {
@@ -67,19 +39,9 @@ class Single {
         return this.client.falkordb.info(section);
     }
     async slowLog(graph) {
-        if (this.#usePool) {
-            return this.client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.slowLog(graph);
-            });
-        }
         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) {

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

@@ -1,8 +1,10 @@
+import { CommandParser } from '@redis/client';
 export declare const IS_READ_ONLY = true;
+export declare function parseCommand(parser: CommandParser, configKey: string): void;
 export declare function transformArguments(configKey: string): Array<string>;
 type ConfigItem = [
     configKey: string,
     value: number
 ];
-export declare function transformReply(): ConfigItem | Array<ConfigItem>;
+export declare function transformReply(reply: unknown): ConfigItem | Array<ConfigItem>;
 export {};

package/dist/src/commands/CONFIG_GET.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IS_READ_ONLY = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 exports.IS_READ_ONLY = true;
+function parseCommand(parser, configKey) {
+    parser.push('GRAPH.CONFIG', 'GET', configKey);
+}
 function transformArguments(configKey) {
     return ['GRAPH.CONFIG', 'GET', configKey];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,2 +1,4 @@
+import { CommandParser } from '@redis/client';
+export declare function parseCommand(parser: CommandParser, configKey: string, value: number | string): void;
 export declare function transformArguments(configKey: string, value: number | string): Array<string>;
-export declare function transformReply(): 'OK';
+export declare function transformReply(reply: unknown): 'OK';

package/dist/src/commands/CONFIG_SET.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
+function parseCommand(parser, configKey, value) {
+    parser.push('GRAPH.CONFIG', 'SET', configKey, typeof value === "string" ? value : value.toString());
+}
 function transformArguments(configKey, value) {
     return [
         'GRAPH.CONFIG',
@@ -9,3 +14,6 @@ function transformArguments(configKey, value) {
         typeof value === "string" ? value : value.toString()
     ];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,3 +1,4 @@
+import { CommandParser } from '@redis/client';
 export declare enum ConstraintType {
     MANDATORY = "MANDATORY",
     UNIQUE = "UNIQUE"
@@ -6,5 +7,6 @@ export declare enum EntityType {
     NODE = "NODE",
     RELATIONSHIP = "RELATIONSHIP"
 }
+export declare function parseCommand(parser: CommandParser, key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): void;
 export declare function transformArguments(key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Array<string>;
-export declare function transformReply(): 'PENDING';
+export declare function transformReply(reply: unknown): 'PENDING';

package/dist/src/commands/CONSTRAINT_CREATE.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityType = exports.ConstraintType = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 var ConstraintType;
 (function (ConstraintType) {
     ConstraintType["MANDATORY"] = "MANDATORY";
@@ -13,6 +15,9 @@ var EntityType;
     EntityType["RELATIONSHIP"] = "RELATIONSHIP";
 })(EntityType || (exports.EntityType = EntityType = {}));
 // GRAPH.CONSTRAINT CREATE key constraintType {NODE label | RELATIONSHIP reltype} PROPERTIES propCount prop [prop...]
+function parseCommand(parser, key, constraintType, entityType, label, ...properties) {
+    parser.push('GRAPH.CONSTRAINT', 'CREATE', key, constraintType, entityType, label, 'PROPERTIES', properties.length.toString(), ...properties);
+}
 function transformArguments(key, constraintType, entityType, label, ...properties) {
     return [
         'GRAPH.CONSTRAINT', 'CREATE',
@@ -20,3 +25,6 @@ function transformArguments(key, constraintType, entityType, label, ...propertie
         'PROPERTIES', properties.length.toString(), ...properties
     ];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,3 +1,5 @@
+import { CommandParser } from '@redis/client';
 import { ConstraintType, EntityType } from "./CONSTRAINT_CREATE";
+export declare function parseCommand(parser: CommandParser, key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): void;
 export declare function transformArguments(key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Array<string>;
-export declare function transformReply(): 'OK';
+export declare function transformReply(reply: unknown): 'OK';

package/dist/src/commands/CONSTRAINT_DROP.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 // GRAPH.CONSTRAINT DROP key constraintType {NODE label | RELATIONSHIP reltype} PROPERTIES propCount prop [prop...]
+function parseCommand(parser, key, constraintType, entityType, label, ...properties) {
+    parser.push('GRAPH.CONSTRAINT', 'DROP', key, constraintType, entityType, label, 'PROPERTIES', properties.length.toString(), ...properties);
+}
 function transformArguments(key, constraintType, entityType, label, ...properties) {
     return [
         'GRAPH.CONSTRAINT', 'DROP',
@@ -9,3 +14,6 @@ function transformArguments(key, constraintType, entityType, label, ...propertie
         'PROPERTIES', properties.length.toString(), ...properties
     ];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,2 +1,4 @@
+import { CommandParser } from '@redis/client';
+export declare function parseCommand(parser: CommandParser, srcGraph: string, destGraph: string): void;
 export declare function transformArguments(srcGraph: string, destGraph: string): Array<string>;
-export declare function transformReply(): 'OK';
+export declare function transformReply(reply: unknown): 'OK';

package/dist/src/commands/COPY.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
+function parseCommand(parser, srcGraph, destGraph) {
+    parser.push('GRAPH.COPY', srcGraph, destGraph);
+}
 function transformArguments(srcGraph, destGraph) {
     return [
         'GRAPH.COPY',
@@ -8,3 +13,6 @@ function transformArguments(srcGraph, destGraph) {
         destGraph
     ];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,3 +1,5 @@
+import { CommandParser } from '@redis/client';
 export declare const FIRST_KEY_INDEX = 1;
+export declare function parseCommand(parser: CommandParser, key: string): void;
 export declare function transformArguments(key: string): Array<string>;
-export declare function transformReply(): string;
+export declare function transformReply(reply: unknown): string;

package/dist/src/commands/DELETE.js

@@ -1,8 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FIRST_KEY_INDEX = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 exports.FIRST_KEY_INDEX = 1;
+function parseCommand(parser, key) {
+    parser.push('GRAPH.DELETE');
+    parser.pushKey(key);
+}
 function transformArguments(key) {
     return ['GRAPH.DELETE', key];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,4 +1,6 @@
+import { CommandParser } from '@redis/client';
 export declare const FIRST_KEY_INDEX = 1;
 export declare const IS_READ_ONLY = true;
+export declare function parseCommand(parser: CommandParser, key: string, query: string): void;
 export declare function transformArguments(key: string, query: string): Array<string>;
-export declare function transfromReply(): Array<string>;
+export declare function transformReply(reply: unknown): Array<string>;

package/dist/src/commands/EXPLAIN.js

@@ -1,9 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 exports.FIRST_KEY_INDEX = 1;
 exports.IS_READ_ONLY = true;
+function parseCommand(parser, key, query) {
+    parser.push('GRAPH.EXPLAIN');
+    parser.pushKey(key);
+    parser.push(query);
+}
 function transformArguments(key, query) {
     return ['GRAPH.EXPLAIN', key, query];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,3 +1,5 @@
+import { CommandParser } from '@redis/client';
 export declare const IS_READ_ONLY = true;
+export declare function parseCommand(parser: CommandParser, section?: string): void;
 export declare function transformArguments(section?: string): Array<string>;
-export declare function transformReply(): Array<string | Array<string>>;
+export declare function transformReply(reply: unknown): Array<string | Array<string>>;

package/dist/src/commands/INFO.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IS_READ_ONLY = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 exports.IS_READ_ONLY = true;
+function parseCommand(parser, section) {
+    parser.push('GRAPH.INFO');
+    if (section) {
+        parser.push(section);
+    }
+}
 function transformArguments(section) {
     const args = ['GRAPH.INFO'];
     if (section) {
@@ -10,3 +18,6 @@ function transformArguments(section) {
     }
     return args;
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,3 +1,5 @@
+import { CommandParser } from '@redis/client';
 export declare const IS_READ_ONLY = true;
+export declare function parseCommand(parser: CommandParser): void;
 export declare function transformArguments(): Array<string>;
-export declare function transformReply(): Array<string>;
+export declare function transformReply(reply: unknown): Array<string>;

package/dist/src/commands/LIST.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IS_READ_ONLY = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 exports.IS_READ_ONLY = true;
+function parseCommand(parser) {
+    parser.push('GRAPH.LIST');
+}
 function transformArguments() {
     return ['GRAPH.LIST'];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,6 +1,8 @@
+import { CommandParser } from '@redis/client';
 export interface MemoryUsageOptions {
     SAMPLES?: number;
 }
+export declare function parseCommand(parser: CommandParser, key: string, options?: MemoryUsageOptions): void;
 export declare function transformArguments(key: string, options?: MemoryUsageOptions): Array<string>;
 export type MemoryUsageReply = Array<string | number | MemoryUsageReply>;
-export declare function transformReply(): MemoryUsageReply;
+export declare function transformReply(reply: unknown): MemoryUsageReply;

package/dist/src/commands/MEMORY_USAGE.js

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

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

@@ -1,4 +1,6 @@
+import { CommandParser } from '@redis/client';
 export declare const FIRST_KEY_INDEX = 1;
 export declare const IS_READ_ONLY = true;
+export declare function parseCommand(parser: CommandParser, key: string, query: string): void;
 export declare function transformArguments(key: string, query: string): Array<string>;
-export declare function transfromReply(): Array<string>;
+export declare function transformReply(reply: unknown): Array<string>;

package/dist/src/commands/PROFILE.js

@@ -1,9 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 exports.FIRST_KEY_INDEX = 1;
 exports.IS_READ_ONLY = true;
+function parseCommand(parser, key, query) {
+    parser.push('GRAPH.PROFILE');
+    parser.pushKey(key);
+    parser.push(query);
+}
 function transformArguments(key, query) {
     return ['GRAPH.PROFILE', key, query];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,7 +1,8 @@
-import { RedisCommandArgument, RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { RedisArgument, CommandParser } from '@redis/client';
 import { QueryOptionsBackwardCompatible } from '.';
 export declare const FIRST_KEY_INDEX = 1;
-export declare function transformArguments(graph: RedisCommandArgument, query: RedisCommandArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): RedisCommandArguments;
+export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): void;
+export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): Array<RedisArgument>;
 type Headers = Array<string>;
 type Data = Array<string | number | null | Data>;
 type Metadata = Array<string>;

package/dist/src/commands/QUERY.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FIRST_KEY_INDEX = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
 const _1 = require(".");
 exports.FIRST_KEY_INDEX = 1;
+function parseCommand(parser, graph, query, options, compact) {
+    const args = (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact);
+    parser.push(...args);
+}
 function transformArguments(graph, query, options, compact) {
     return (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact);
 }

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

@@ -1,6 +1,7 @@
-import { RedisCommandArgument, RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { RedisArgument, CommandParser } from '@redis/client';
 import { QueryOptionsBackwardCompatible } from '.';
 export { FIRST_KEY_INDEX } from './QUERY';
 export declare const IS_READ_ONLY = true;
-export declare function transformArguments(graph: RedisCommandArgument, query: RedisCommandArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): RedisCommandArguments;
+export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): void;
+export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): Array<RedisArgument>;
 export { transformReply } from './QUERY';

package/dist/src/commands/RO_QUERY.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformReply = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 const _1 = require(".");
 var QUERY_1 = require("./QUERY");
 Object.defineProperty(exports, "FIRST_KEY_INDEX", { enumerable: true, get: function () { return QUERY_1.FIRST_KEY_INDEX; } });
 exports.IS_READ_ONLY = true;
+function parseCommand(parser, graph, query, options, compact) {
+    const args = (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact);
+    parser.push(...args);
+}
 function transformArguments(graph, query, options, compact) {
     return (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact);
 }

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

@@ -1,3 +1,5 @@
+import { CommandParser } from '@redis/client';
 export declare const IS_READ_ONLY = true;
+export declare function parseCommand(parser: CommandParser, dbname: string): void;
 export declare function transformArguments(dbname: string): Array<string>;
-export declare function transformReply(): Array<string>;
+export declare function transformReply(reply: unknown): Array<string>;

package/dist/src/commands/SENTINEL_MASTER.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IS_READ_ONLY = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 exports.IS_READ_ONLY = true;
+function parseCommand(parser, dbname) {
+    parser.push('SENTINEL', 'MASTER', dbname);
+}
 function transformArguments(dbname) {
     return ['SENTINEL', 'MASTER', dbname];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,3 +1,5 @@
+import { CommandParser } from '@redis/client';
 export declare const IS_READ_ONLY = true;
+export declare function parseCommand(parser: CommandParser): void;
 export declare function transformArguments(): Array<string>;
-export declare function transformReply(): Array<Array<string>>;
+export declare function transformReply(reply: unknown): Array<Array<string>>;

package/dist/src/commands/SENTINEL_MASTERS.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IS_READ_ONLY = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 exports.IS_READ_ONLY = true;
+function parseCommand(parser) {
+    parser.push('SENTINEL', 'MASTERS');
+}
 function transformArguments() {
     return ['SENTINEL', 'MASTERS'];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,5 +1,7 @@
+import { CommandParser } from '@redis/client';
 export declare const IS_READ_ONLY = true;
 export declare const FIRST_KEY_INDEX = 1;
+export declare function parseCommand(parser: CommandParser, key: string): void;
 export declare function transformArguments(key: string): string[];
 type SlowLogRawReply = Array<[
     timestamp: string,

package/dist/src/commands/SLOWLOG.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FIRST_KEY_INDEX = exports.IS_READ_ONLY = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
 exports.IS_READ_ONLY = true;
 exports.FIRST_KEY_INDEX = 1;
+function parseCommand(parser, key) {
+    parser.push('GRAPH.SLOWLOG');
+    parser.pushKey(key);
+}
 function transformArguments(key) {
     return ['GRAPH.SLOWLOG', key];
 }

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

@@ -1,2 +1,4 @@
+import { CommandParser } from '@redis/client';
+export declare function parseCommand(parser: CommandParser, lib: string): void;
 export declare function transformArguments(lib: string): Array<string>;
-export declare function transformReply(): string;
+export declare function transformReply(reply: unknown): string;

package/dist/src/commands/UDF_DELETE.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
+function parseCommand(parser, lib) {
+    parser.push('GRAPH.UDF', 'DELETE', lib);
+}
 function transformArguments(lib) {
     return ['GRAPH.UDF', 'DELETE', lib];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,2 +1,4 @@
+import { CommandParser } from '@redis/client';
+export declare function parseCommand(parser: CommandParser): void;
 export declare function transformArguments(): Array<string>;
-export declare function transformReply(): string;
+export declare function transformReply(reply: unknown): string;

package/dist/src/commands/UDF_FLUSH.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
+function parseCommand(parser) {
+    parser.push('GRAPH.UDF', 'FLUSH');
+}
 function transformArguments() {
     return ['GRAPH.UDF', 'FLUSH'];
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,5 +1,7 @@
+import { CommandParser } from '@redis/client';
 export declare const IS_READ_ONLY = true;
 export type UdfLibraryEntry = [string, string[]] | [string, string[], string];
 export type UdfListReply = UdfLibraryEntry[];
+export declare function parseCommand(parser: CommandParser, lib?: string, withCode?: boolean): void;
 export declare function transformArguments(lib?: string, withCode?: boolean): Array<string>;
-export declare function transformReply(): UdfListReply;
+export declare function transformReply(reply: unknown): UdfListReply;

package/dist/src/commands/UDF_LIST.js

@@ -1,8 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IS_READ_ONLY = void 0;
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
 exports.IS_READ_ONLY = true;
+function parseCommand(parser, lib, withCode = false) {
+    parser.push('GRAPH.UDF', 'LIST');
+    if (lib !== undefined) {
+        parser.push(lib);
+    }
+    if (withCode) {
+        parser.push('WITHCODE');
+    }
+}
 function transformArguments(lib, withCode = false) {
     const args = ['GRAPH.UDF', 'LIST'];
     if (lib !== undefined) {
@@ -13,3 +24,6 @@ function transformArguments(lib, withCode = false) {
     }
     return args;
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -1,2 +1,4 @@
+import { CommandParser } from '@redis/client';
+export declare function parseCommand(parser: CommandParser, name: string, script: string | Function, replace?: boolean): void;
 export declare function transformArguments(name: string, script: string | Function, replace?: boolean): Array<string>;
-export declare function transformReply(): string;
+export declare function transformReply(reply: unknown): string;

package/dist/src/commands/UDF_LOAD.js

@@ -1,6 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
+exports.transformReply = transformReply;
+function parseCommand(parser, name, script, replace = false) {
+    parser.push('GRAPH.UDF', 'LOAD');
+    if (replace) {
+        parser.push('REPLACE');
+    }
+    parser.push(name);
+    // If script is a function, convert it to string and add falkor.register() call
+    let scriptStr;
+    if (typeof script === 'function') {
+        const functionStr = script.toString();
+        const functionName = script.name;
+        if (!functionName) {
+            throw new Error('Function must have a name to be registered as a UDF');
+        }
+        // Add the function definition and register call
+        scriptStr = `${functionStr}\nfalkor.register("${functionName}", ${functionName});`;
+    }
+    else {
+        scriptStr = script;
+    }
+    parser.push(scriptStr);
+}
 function transformArguments(name, script, replace = false) {
     const args = ['GRAPH.UDF', 'LOAD'];
     if (replace) {
@@ -24,3 +48,6 @@ function transformArguments(name, script, replace = false) {
     args.push(scriptStr);
     return args;
 }
+function transformReply(reply) {
+    return reply;
+}

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

@@ -18,7 +18,7 @@ import * as UDF_LOAD from './UDF_LOAD';
 import * as UDF_LIST from './UDF_LIST';
 import * as UDF_FLUSH from './UDF_FLUSH';
 import * as UDF_DELETE from './UDF_DELETE';
-import { RedisCommandArgument, RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { RedisArgument } from '@redis/client';
 declare const _default: {
     CONFIG_GET: typeof CONFIG_GET;
     configGet: typeof CONFIG_GET;
@@ -71,5 +71,5 @@ export interface QueryOptions {
     TIMEOUT?: number;
 }
 export type QueryOptionsBackwardCompatible = QueryOptions | number;
-export declare function pushQueryArguments(args: RedisCommandArguments, graph: RedisCommandArgument, query: RedisCommandArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): RedisCommandArguments;
-export { UdfListReply, UdfLibraryEntry } from './UDF_LIST';
+export declare function pushQueryArguments(args: Array<RedisArgument>, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): Array<RedisArgument>;
+export type { UdfListReply, UdfLibraryEntry } from './UDF_LIST';

package/dist/src/falkordb.d.ts

@@ -5,17 +5,16 @@ import { RedisClientOptions, RedisFunctions, RedisScripts } from 'redis';
 import Graph from './graph';
 import commands from './commands';
 import { RedisClusterOptions } from '@redis/client';
-import { Options as PoolOptions } from 'generic-pool';
 import { SingleGraphConnection } from './clients/single';
 type NetSocketOptions = Partial<net.SocketConnectOpts> & {
     tls?: false;
 };
 export type TypedRedisClientOptions = RedisClientOptions<{
     falkordb: typeof commands;
-}, RedisFunctions, RedisScripts>;
+}, RedisFunctions, RedisScripts, 2>;
 export type TypedRedisClusterClientOptions = RedisClusterOptions<{
     falkordb: typeof commands;
-}, RedisFunctions, RedisScripts>;
+}, RedisFunctions, RedisScripts, 2>;
 interface TlsSocketOptions extends tls.ConnectionOptions {
     tls: true;
 }
@@ -76,10 +75,6 @@ export interface FalkorDBOptions {
      * Tag to append to library name that is sent to the Redis server
      */
     clientInfoTag?: string;
-    /**
-     * Connection pool options
-     */
-    poolOptions?: PoolOptions;
 }
 export default class FalkorDB extends EventEmitter {
     #private;

package/dist/src/falkordb.js

@@ -27,10 +27,6 @@ class FalkorDB extends events_1.EventEmitter {
         if (redisOption.url && redisOption.url.startsWith('falkor')) {
             redisOption.url = redisOption.url.replace('falkor', 'redis');
         }
-        // Just copy the pool options to the isolation pool options as expected by the redis client
-        if (options?.poolOptions) {
-            redisOption.isolationPoolOptions = options.poolOptions;
-        }
         redisOption.modules = {
             falkordb: commands_1.default
         };

package/dist/src/graph.d.ts

@@ -1,4 +1,4 @@
-import { RedisCommandArgument } from "@redis/client/dist/lib/commands";
+import { RedisArgument } from "@redis/client";
 import { QueryOptions } from "./commands";
 import { QueryReply } from "./commands/QUERY";
 import { ConstraintType, EntityType } from "./commands/CONSTRAINT_CREATE";
@@ -11,8 +11,8 @@ export type GraphReply<T> = Omit<QueryReply, "headers" | "data"> & {
 export default class Graph {
     #private;
     constructor(client: Client, name: string);
-    query<T>(query: RedisCommandArgument, options?: QueryOptions): Promise<GraphReply<T>>;
-    roQuery<T>(query: RedisCommandArgument, options?: QueryOptions): Promise<GraphReply<T>>;
+    query<T>(query: RedisArgument, options?: QueryOptions): Promise<GraphReply<T>>;
+    roQuery<T>(query: RedisArgument, options?: QueryOptions): Promise<GraphReply<T>>;
     delete(): Promise<void>;
     explain(query: string): Promise<any>;
     profile(query: string): Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "falkordb",
-  "version": "6.5.1",
+  "version": "6.6.0",
   "description": "A FalkorDB javascript library",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -44,17 +44,17 @@
     "@typescript-eslint/parser": "^8.18.2",
     "eslint": "^9.17.0",
     "gh-pages": "^6.2.0",
-    "jest": "^29.7.0",
+    "jest": "^30.2.0",
     "release-it": "^19.0.3",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@js-temporal/polyfill": "^0.5.1",
-    "@redis/client": "^1.6.0",
+    "@redis/client": "^5.10.0",
     "cluster-key-slot": "1.1.2",
     "generic-pool": "^3.9.0",
     "lodash": "^4.17.21",
-    "redis": "^4.7.0"
+    "redis": "^5.10.0"
   }
 }