falkordb 6.6.0-beta.1 → 6.6.1

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 } from './src/falkordb';
+export type { FalkorDBOptions } from './src/falkordb';

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

@@ -1,18 +1,19 @@
-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";
 import { SingleGraphConnection } from "./single";
 import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
+import { UdfListReply } from "../commands/UDF_LIST";
 export interface Client {
     init(falkordb: FalkorDB): Promise<void>;
     list(): Promise<Array<string>>;
     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>;
@@ -25,6 +26,10 @@ export interface Client {
     }[]>;
     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>;
+    udfLoad(name: string, script: string | Function, replace?: boolean): Promise<string>;
+    udfList(lib?: string, withCode?: boolean): Promise<UdfListReply>;
+    udfFlush(): Promise<string>;
+    udfDelete(lib: string): Promise<string>;
     /**
      * @deprecated Use `disconnect` instead
      */

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

@@ -1,14 +1,15 @@
 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";
 import { SingleGraphConnection } from "./single";
 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.
  */
@@ -17,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[];
@@ -28,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[];
@@ -38,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>;
@@ -53,7 +54,11 @@ export declare class Cluster implements Client {
     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>;
+    udfLoad(name: string, script: string | Function, replace?: boolean): Promise<string>;
+    udfList(lib?: string, withCode?: boolean): Promise<UdfListReply>;
+    udfFlush(): Promise<string>;
+    udfDelete(lib: string): Promise<string>;
+    profile<_T>(graph: string, query: string): Promise<string[]>;
     quit(): Promise<void>;
     disconnect(): Promise<void>;
 }

package/dist/src/clients/cluster.js

@@ -86,6 +86,18 @@ class Cluster {
         const reply = this.#client.falkordb.constraintDrop(graph, constraintType, entityType, label, ...properties);
         return reply.then(() => { });
     }
+    async udfLoad(name, script, replace = false) {
+        return this.#client.falkordb.udfLoad(name, script, replace);
+    }
+    async udfList(lib, withCode = false) {
+        return this.#client.falkordb.udfList(lib, withCode);
+    }
+    async udfFlush() {
+        return this.#client.falkordb.udfFlush();
+    }
+    async udfDelete(lib) {
+        return this.#client.falkordb.udfDelete(lib);
+    }
     async profile(graph, query) {
         return this.#client.falkordb.profile(graph, query);
     }

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

@@ -1,10 +1,11 @@
-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";
 import { Client } from "./client";
 import { SingleGraphConnection } from "./single";
 import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
+import { UdfListReply } from "../commands/UDF_LIST";
 /**
  * The `NullClient` class is a placeholder implementation of the `Client` interface.
  *
@@ -23,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>;
@@ -38,6 +39,10 @@ export declare class NullClient implements Client {
     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>;
+    udfLoad(_name: string, _script: string | Function, _replace?: boolean): Promise<string>;
+    udfList(_lib?: string, _withCode?: boolean): Promise<UdfListReply>;
+    udfFlush(): Promise<string>;
+    udfDelete(_lib: string): Promise<string>;
     quit(): Promise<void>;
     disconnect(): Promise<void>;
 }

package/dist/src/clients/nullClient.js

@@ -61,6 +61,18 @@ class NullClient {
     constraintDrop(_graph, _constraintType, _entityType, _label, ..._properties) {
         throw new Error("Method not implemented.");
     }
+    udfLoad(_name, _script, _replace) {
+        throw new Error("Method not implemented.");
+    }
+    udfList(_lib, _withCode) {
+        throw new Error("Method not implemented.");
+    }
+    udfFlush() {
+        throw new Error("Method not implemented.");
+    }
+    udfDelete(_lib) {
+        throw new Error("Method not implemented.");
+    }
     quit() {
         throw new Error("Method not implemented.");
     }

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

@@ -1,19 +1,19 @@
 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";
 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[];
@@ -22,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[];
@@ -32,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>;
@@ -47,6 +47,10 @@ export declare class Single implements Client {
     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>;
+    udfLoad(name: string, script: string | Function, replace?: boolean): Promise<string>;
+    udfList(lib?: string, withCode?: boolean): Promise<UdfListReply>;
+    udfFlush(): Promise<string>;
+    udfDelete(lib: string): Promise<string>;
     copy<_T>(srcGraph: string, destGraph: string): Promise<"OK">;
     quit(): Promise<void>;
     disconnect(): 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) {
@@ -90,6 +52,18 @@ class Single {
         const reply = this.client.falkordb.constraintDrop(graph, constraintType, entityType, label, ...properties);
         return reply.then(() => { });
     }
+    async udfLoad(name, script, replace = false) {
+        return this.client.falkordb.udfLoad(name, script, replace);
+    }
+    async udfList(lib, withCode = false) {
+        return this.client.falkordb.udfList(lib, withCode);
+    }
+    async udfFlush() {
+        return this.client.falkordb.udfFlush();
+    }
+    async udfDelete(lib) {
+        return this.client.falkordb.udfDelete(lib);
+    }
     async copy(srcGraph, destGraph) {
         return this.client.falkordb.copy(srcGraph, destGraph);
     }

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

@@ -14,7 +14,11 @@ 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';
+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 { RedisArgument } from '@redis/client';
 declare const _default: {
     CONFIG_GET: typeof CONFIG_GET;
     configGet: typeof CONFIG_GET;
@@ -48,6 +52,14 @@ declare const _default: {
     sentinelMasters: typeof SENTINEL_MASTERS;
     MEMORY_USAGE: typeof MEMORY_USAGE;
     memoryUsage: typeof MEMORY_USAGE;
+    UDF_LOAD: typeof UDF_LOAD;
+    udfLoad: typeof UDF_LOAD;
+    UDF_LIST: typeof UDF_LIST;
+    udfList: typeof UDF_LIST;
+    UDF_FLUSH: typeof UDF_FLUSH;
+    udfFlush: typeof UDF_FLUSH;
+    UDF_DELETE: typeof UDF_DELETE;
+    udfDelete: typeof UDF_DELETE;
 };
 export default _default;
 type QueryParam = null | string | number | boolean | QueryParams | Array<QueryParam>;
@@ -59,4 +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 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/commands/index.js

@@ -17,6 +17,10 @@ const COPY = require("./COPY");
 const SENTINEL_MASTER = require("./SENTINEL_MASTER");
 const SENTINEL_MASTERS = require("./SENTINEL_MASTERS");
 const MEMORY_USAGE = require("./MEMORY_USAGE");
+const UDF_LOAD = require("./UDF_LOAD");
+const UDF_LIST = require("./UDF_LIST");
+const UDF_FLUSH = require("./UDF_FLUSH");
+const UDF_DELETE = require("./UDF_DELETE");
 exports.default = {
     CONFIG_GET,
     configGet: CONFIG_GET,
@@ -50,6 +54,14 @@ exports.default = {
     sentinelMasters: SENTINEL_MASTERS,
     MEMORY_USAGE,
     memoryUsage: MEMORY_USAGE,
+    UDF_LOAD,
+    udfLoad: UDF_LOAD,
+    UDF_LIST,
+    udfList: UDF_LIST,
+    UDF_FLUSH,
+    udfFlush: UDF_FLUSH,
+    UDF_DELETE,
+    udfDelete: UDF_DELETE,
 };
 function pushQueryArguments(args, graph, query, options, compact) {
     args.push(graph);

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;
@@ -90,6 +85,10 @@ export default class FalkorDB extends EventEmitter {
     configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
     configSet(configKey: string, value: number | string): Promise<void>;
     info(section?: string): Promise<(string | string[])[]>;
+    udfLoad(name: string, script: string | Function, replace?: boolean): Promise<string>;
+    udfList(lib?: string, withCode?: boolean): Promise<import("./commands").UdfListReply>;
+    udfFlush(): Promise<string>;
+    udfDelete(lib: string): Promise<string>;
     /**
      * Closes the client.
      */

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
         };
@@ -66,6 +62,18 @@ class FalkorDB extends events_1.EventEmitter {
     async info(section) {
         return this.#client.info(section);
     }
+    async udfLoad(name, script, replace = false) {
+        return this.#client.udfLoad(name, script, replace);
+    }
+    async udfList(lib, withCode = false) {
+        return this.#client.udfList(lib, withCode);
+    }
+    async udfFlush() {
+        return this.#client.udfFlush();
+    }
+    async udfDelete(lib) {
+        return this.#client.udfDelete(lib);
+    }
     /**
      * Closes the client.
      */

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.6.0-beta.1",
+  "version": "6.6.1",
   "description": "A FalkorDB javascript library",
   "license": "MIT",
   "main": "./dist/index.js",