falkordb 6.2.0-beta.1 → 6.2.0

package/README.md

@@ -44,8 +44,15 @@ console.log('Connected to FalkorDB')
 
 const graph = db.selectGraph('myGraph')
 
-const result = await graph.query('MATCH (n) RETURN n')
-console.log(result)
+await graph.query(`CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {name:'Yamaha'}),
+        (:Rider {name:'Dani Pedrosa'})-[:rides]->(:Team {name:'Honda'}),
+        (:Rider {name:'Andrea Dovizioso'})-[:rides]->(:Team {name:'Ducati'})`)
+
+result = await graph.query(`MATCH (r:Rider)-[:rides]->(t:Team) 
+                            WHERE t.name = $name RETURN r.name`, 
+                            {params: {name: 'Yamaha'}})
+                            
+console.log(result) // Valentino Rossi
 
 console.log(await db.list())
 console.log(await db.info())
@@ -53,6 +60,8 @@ console.log(await db.info())
 db.close()
 ```
 
+To learn more about Cypher query language check: https://docs.falkordb.com/cypher/
+
 #### `.close()`
 
 Forcibly close a client's connection to FalkorDB immediately. Calling `close` will not send further pending commands to the Redis server, or wait for or parse outstanding responses.

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

@@ -0,0 +1,26 @@
+import { RedisCommandArgument } from "@redis/client/dist/lib/commands";
+import { QueryOptions } from "../commands";
+import { ConstraintType, EntityType } from "../graph";
+import FalkorDB from "../falkordb";
+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): Promise<any>;
+    profile<T>(graph: string, query: RedisCommandArgument): Promise<any>;
+    roQuery<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions): Promise<any>;
+    copy<T>(srcGraph: string, destGraph: string): Promise<any>;
+    delete(graph: string): Promise<void>;
+    explain(graph: string, query: string): Promise<any>;
+    slowLog(graph: string): Promise<{
+        timestamp: Date;
+        command: string;
+        query: string;
+        took: number;
+    }[]>;
+    constraintCreate(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
+    constraintDrop(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
+    quit(): Promise<void>;
+}

package/dist/src/clients/client.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,53 @@
+import { Client } from "./client";
+import { ConstraintType, EntityType } from "../graph";
+import { RedisCommandArgument, RedisFunctions, RedisScripts } from "@redis/client/dist/lib/commands";
+import commands, { QueryOptions } from "../commands";
+import { RedisClusterType } from "@redis/client";
+import FalkorDB from "../falkordb";
+import { SingleGraphConnection } from "./single";
+export type ClusterGraphConnection = RedisClusterType<{
+    falkordb: typeof commands;
+}, RedisFunctions, RedisScripts>;
+/**
+ * A client that connects to a Redis Cluster.
+ */
+export declare class Cluster implements Client {
+    #private;
+    constructor(client: SingleGraphConnection);
+    init(falkordb: FalkorDB): Promise<void>;
+    query<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions): Promise<{
+        headers: undefined;
+        data: undefined;
+        metadata: string[];
+    } | {
+        headers: string[];
+        data: (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[];
+        metadata: string[];
+    }>;
+    roQuery<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions): Promise<{
+        headers: undefined;
+        data: undefined;
+        metadata: string[];
+    } | {
+        headers: string[];
+        data: (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[];
+        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 | 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>;
+    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[])[]>;
+    copy<T>(srcGraph: string, destGraph: string): Promise<"OK">;
+    slowLog(graph: string): Promise<{
+        timestamp: Date;
+        command: string;
+        query: string;
+        took: number;
+    }[]>;
+    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 | 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>;
+    quit(): Promise<void>;
+}

package/dist/src/clients/cluster.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cluster = void 0;
+const client_1 = require("@redis/client");
+const lodash = require("lodash");
+/**
+ * A client that connects to a Redis Cluster.
+ */
+class Cluster {
+    #client;
+    constructor(client) {
+        // Convert the single client options to a cluster client options
+        const redisClusterOption = client.options;
+        redisClusterOption.rootNodes = [client.options];
+        // Remove the URL from the defaults so it won't override the dynamic cluster URLs
+        const defaults = lodash.cloneDeep(client.options);
+        defaults?.url && delete defaults.url;
+        redisClusterOption.defaults = defaults;
+        redisClusterOption.maxCommandRedirections = 100000;
+        client.disconnect();
+        this.#client = (0, client_1.createCluster)(redisClusterOption);
+    }
+    async init(falkordb) {
+        await this.#client
+            .on('error', err => falkordb.emit('error', err)) // Forward errors
+            .connect();
+    }
+    async query(graph, query, options) {
+        return this.#client.falkordb.query(graph, query, options, true);
+    }
+    async roQuery(graph, query, options) {
+        return this.#client.falkordb.roQuery(graph, query, options, true);
+    }
+    async delete(graph) {
+        const reply = this.#client.falkordb.delete(graph);
+        return reply.then(() => { });
+    }
+    async explain(graph, query) {
+        return this.#client.falkordb.explain(graph, query);
+    }
+    async list() {
+        return this.#client.falkordb.list();
+    }
+    async configGet(configKey) {
+        return this.#client.falkordb.configGet(configKey);
+    }
+    async configSet(configKey, value) {
+        const reply = this.#client.falkordb.configSet(configKey, value);
+        return reply.then(() => { });
+    }
+    async info(section) {
+        return this.#client.falkordb.info(section);
+    }
+    async copy(srcGraph, destGraph) {
+        return this.#client.falkordb.copy(srcGraph, destGraph);
+    }
+    slowLog(graph) {
+        return this.#client.falkordb.slowLog(graph);
+    }
+    async constraintCreate(graph, constraintType, entityType, label, ...properties) {
+        const reply = this.#client.falkordb.constraintCreate(graph, constraintType, entityType, label, ...properties);
+        return reply.then(() => { });
+    }
+    async constraintDrop(graph, constraintType, entityType, label, ...properties) {
+        const reply = this.#client.falkordb.constraintDrop(graph, constraintType, entityType, label, ...properties);
+        return reply.then(() => { });
+    }
+    async profile(graph, query) {
+        return this.#client.falkordb.profile(graph, query);
+    }
+    async quit() {
+        const reply = this.#client.quit();
+        return reply.then(() => { });
+    }
+}
+exports.Cluster = Cluster;

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

@@ -0,0 +1,38 @@
+import { RedisCommandArgument } from "@redis/client/dist/lib/commands";
+import { QueryOptions } from "../commands";
+import FalkorDB from "../falkordb";
+import { ConstraintType, EntityType } from "../graph";
+import { Client } from "./client";
+/**
+ * The `NullClient` class is a placeholder implementation of the `Client` interface.
+ *
+ * This class is designed to be used in scenarios where a client is required, but no actual
+ * implementation is available. All methods in this class throw a "Method not implemented."
+ * error, indicating that the functionality has not been provided.
+ *
+ * The `NullClient` can serve as a base class or a stub for future implementations, or as a
+ * fallback in cases where a functional client is not needed or cannot be instantiated.
+ *
+ */
+export declare class NullClient implements 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): Promise<any>;
+    profile<T>(graph: string, query: RedisCommandArgument): Promise<any>;
+    roQuery<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions): Promise<any>;
+    copy<T>(srcGraph: string, destGraph: string): Promise<any>;
+    delete(graph: string): Promise<void>;
+    explain(graph: string, query: string): Promise<any>;
+    slowLog(graph: string): Promise<{
+        timestamp: Date;
+        command: string;
+        query: string;
+        took: number;
+    }[]>;
+    constraintCreate(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
+    constraintDrop(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
+    quit(): Promise<void>;
+}

package/dist/src/clients/nullClient.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullClient = void 0;
+/**
+ * The `NullClient` class is a placeholder implementation of the `Client` interface.
+ *
+ * This class is designed to be used in scenarios where a client is required, but no actual
+ * implementation is available. All methods in this class throw a "Method not implemented."
+ * error, indicating that the functionality has not been provided.
+ *
+ * The `NullClient` can serve as a base class or a stub for future implementations, or as a
+ * fallback in cases where a functional client is not needed or cannot be instantiated.
+ *
+ */
+class NullClient {
+    init(falkordb) {
+        throw new Error("Method not implemented.");
+    }
+    list() {
+        throw new Error("Method not implemented.");
+    }
+    configGet(configKey) {
+        throw new Error("Method not implemented.");
+    }
+    configSet(configKey, value) {
+        throw new Error("Method not implemented.");
+    }
+    info(section) {
+        throw new Error("Method not implemented.");
+    }
+    query(graph, query, options) {
+        throw new Error("Method not implemented.");
+    }
+    profile(graph, query) {
+        throw new Error("Method not implemented.");
+    }
+    roQuery(graph, query, options) {
+        throw new Error("Method not implemented.");
+    }
+    copy(srcGraph, destGraph) {
+        throw new Error("Method not implemented.");
+    }
+    delete(graph) {
+        throw new Error("Method not implemented.");
+    }
+    explain(graph, query) {
+        throw new Error("Method not implemented.");
+    }
+    slowLog(graph) {
+        throw new Error("Method not implemented.");
+    }
+    constraintCreate(graph, constraintType, entityType, label, ...properties) {
+        throw new Error("Method not implemented.");
+    }
+    constraintDrop(graph, constraintType, entityType, label, ...properties) {
+        throw new Error("Method not implemented.");
+    }
+    quit() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.NullClient = NullClient;

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

@@ -0,0 +1,10 @@
+import { Single } from "./single";
+import FalkorDB from "../falkordb";
+export declare class Sentinel extends Single {
+    init(falkordb: FalkorDB): Promise<void>;
+    /**
+     * Connect to the server using the details from sentinel server
+     * Register error event to reconnect on error from the sentinel server
+     */
+    private tryConnectSentinelServer;
+}

package/dist/src/clients/sentinel.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sentinel = void 0;
+const single_1 = require("./single");
+const client_1 = require("@redis/client");
+function extractDetails(masters) {
+    const allDetails = [];
+    for (const master of masters) {
+        const details = {};
+        for (let i = 0; i < master.length; i += 2) {
+            details[master[i]] = master[i + 1];
+        }
+        allDetails.push(details);
+    }
+    return allDetails;
+}
+class Sentinel extends single_1.Single {
+    init(falkordb) {
+        const redisOption = (this.client.options ?? {});
+        return this.tryConnectSentinelServer(this.client, redisOption, falkordb);
+    }
+    /**
+     * Connect to the server using the details from sentinel server
+     * Register error event to reconnect on error from the sentinel server
+     */
+    async tryConnectSentinelServer(client, redisOption, falkordb) {
+        // TODO support multi sentinels
+        const masters = await client.falkordb.sentinelMasters();
+        const details = extractDetails(masters);
+        if (details.length > 1) {
+            throw new Error('Multiple masters are not supported');
+        }
+        // Connect to the server with the details from sentinel
+        const socketOptions = {
+            ...redisOption.socket,
+            host: details[0]['ip'],
+            port: parseInt(details[0]['port'])
+        };
+        const serverOptions = {
+            ...redisOption,
+            socket: socketOptions
+        };
+        const realClient = (0, client_1.createClient)(serverOptions);
+        // Set original client as sentinel and server client as client
+        this.client = realClient;
+        await realClient
+            .on('error', async (err) => {
+            console.debug('Error on server connection', err);
+            // Disconnect the client to avoid further errors and retries
+            realClient.disconnect();
+            // If error occurs on previous server connection, no need to reconnect
+            if (this.client !== realClient) {
+                return;
+            }
+            try {
+                await this.tryConnectSentinelServer(client, redisOption, falkordb);
+                console.debug('Connected to server');
+            }
+            catch (e) {
+                console.debug('Error on server reconnect', e);
+                // Forward errors if reconnection fails
+                falkordb.emit('error', err);
+            }
+        })
+            .connect();
+    }
+}
+exports.Sentinel = Sentinel;

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

@@ -0,0 +1,50 @@
+import { Client } from "./client";
+import { ConstraintType, EntityType } from "../graph";
+import { RedisCommandArgument, RedisFunctions, RedisScripts } from "@redis/client/dist/lib/commands";
+import commands, { QueryOptions } from "../commands";
+import { RedisClientType } from "@redis/client";
+import FalkorDB from "../falkordb";
+export type SingleGraphConnection = RedisClientType<{
+    falkordb: typeof commands;
+}, RedisFunctions, RedisScripts>;
+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): Promise<{
+        headers: undefined;
+        data: undefined;
+        metadata: string[];
+    } | {
+        headers: string[];
+        data: (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[];
+        metadata: string[];
+    }>;
+    roQuery<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions): Promise<{
+        headers: undefined;
+        data: undefined;
+        metadata: string[];
+    } | {
+        headers: string[];
+        data: (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | (string | number | any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[];
+        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 | 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 | 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>;
+    list(): Promise<string[]>;
+    configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
+    configSet(configKey: string, value: number | string): Promise<void>;
+    info(section?: string): Promise<(string | string[])[]>;
+    slowLog(graph: string): Promise<{
+        timestamp: Date;
+        command: string;
+        query: string;
+        took: number;
+    }[]>;
+    constraintCreate(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
+    constraintDrop(graph: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
+    copy<T>(srcGraph: string, destGraph: string): Promise<"OK">;
+    quit(): Promise<void>;
+}

package/dist/src/clients/single.js

@@ -0,0 +1,95 @@
+"use strict";
+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) {
+        const reply = this.#usePool ?
+            await this.client.executeIsolated(async (isolatedClient) => {
+                return isolatedClient.falkordb.query(graph, query, options, true);
+            })
+            :
+                await this.client.falkordb.query(graph, query, options, true);
+        return reply;
+    }
+    async roQuery(graph, query, options) {
+        const reply = this.#usePool ?
+            await this.client.executeIsolated(async (isolatedClient) => {
+                return isolatedClient.falkordb.roQuery(graph, query, options, true);
+            })
+            :
+                await this.client.falkordb.roQuery(graph, query, options, true);
+        return reply;
+    }
+    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() {
+        return this.client.falkordb.list();
+    }
+    async configGet(configKey) {
+        return this.client.falkordb.configGet(configKey);
+    }
+    async configSet(configKey, value) {
+        const reply = this.client.falkordb.configSet(configKey, value);
+        return reply.then(() => { });
+    }
+    async info(section) {
+        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 constraintCreate(graph, constraintType, entityType, label, ...properties) {
+        const reply = this.client.falkordb.constraintCreate(graph, constraintType, entityType, label, ...properties);
+        return reply.then(() => { });
+    }
+    async constraintDrop(graph, constraintType, entityType, label, ...properties) {
+        const reply = this.client.falkordb.constraintDrop(graph, constraintType, entityType, label, ...properties);
+        return reply.then(() => { });
+    }
+    async copy(srcGraph, destGraph) {
+        return this.client.falkordb.copy(srcGraph, destGraph);
+    }
+    async quit() {
+        const reply = this.client.quit();
+        return reply.then(() => { });
+    }
+}
+exports.Single = Single;

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

@@ -1,2 +1,2 @@
-export declare function transformArguments(configKey: string, value: number): Array<string>;
+export declare function transformArguments(configKey: string, value: number | string): Array<string>;
 export declare function transformReply(): 'OK';

package/dist/src/commands/CONFIG_SET.js

@@ -6,6 +6,6 @@ function transformArguments(configKey, value) {
         'GRAPH.CONFIG',
         'SET',
         configKey,
-        value.toString()
+        typeof value === "string" ? value : value.toString()
     ];
 }

package/dist/src/falkordb.d.ts

@@ -1,11 +1,21 @@
 import * as tls from 'tls';
 import * as net from 'net';
 import { EventEmitter } from 'events';
-import Graph, { GraphConnection } from './graph';
+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 { Client } from './clients/client';
 type NetSocketOptions = Partial<net.SocketConnectOpts> & {
     tls?: false;
 };
+export type TypedRedisClientOptions = RedisClientOptions<{
+    falkordb: typeof commands;
+}, RedisFunctions, RedisScripts>;
+export type TypedRedisClusterClientOptions = RedisClusterOptions<{
+    falkordb: typeof commands;
+}, RedisFunctions, RedisScripts>;
 interface TlsSocketOptions extends tls.ConnectionOptions {
     tls: true;
 }
@@ -73,18 +83,16 @@ export interface FalkorDBOptions {
 }
 export default class FalkorDB extends EventEmitter {
     #private;
-    private constructor();
-    private connectServer;
     static connect(options?: FalkorDBOptions): Promise<FalkorDB>;
     selectGraph(graphId: string): Graph;
-    get connection(): GraphConnection;
+    get connection(): Client;
     list(): Promise<string[]>;
     configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
-    configSet(configKey: string, value: number): Promise<"OK">;
+    configSet(configKey: string, value: number | string): Promise<void>;
     info(section?: string): Promise<(string | string[])[]>;
     /**
      * Closes the client.
      */
-    close(): Promise<string>;
+    close(): Promise<void>;
 }
 export {};

package/dist/src/falkordb.js

@@ -4,66 +4,22 @@ const events_1 = require("events");
 const redis_1 = require("redis");
 const graph_1 = require("./graph");
 const commands_1 = require("./commands");
-function extractDetails(masters) {
-    const allDetails = [];
-    for (const master of masters) {
-        const details = {};
-        for (let i = 0; i < master.length; i += 2) {
-            details[master[i]] = master[i + 1];
-        }
-        allDetails.push(details);
+const single_1 = require("./clients/single");
+const sentinel_1 = require("./clients/sentinel");
+const cluster_1 = require("./clients/cluster");
+const nullClient_1 = require("./clients/nullClient");
+async function clientFactory(client) {
+    const info = await client.info("server");
+    if (info.includes("redis_mode:sentinel")) {
+        return new sentinel_1.Sentinel(client);
+    }
+    else if (info.includes("redis_mode:cluster")) {
+        return new cluster_1.Cluster(client);
     }
-    return allDetails;
+    return new single_1.Single(client);
 }
 class FalkorDB extends events_1.EventEmitter {
-    #client;
-    #sentinel;
-    constructor(client) {
-        super();
-        this.#client = client;
-    }
-    async connectServer(client, redisOption) {
-        // If not connected to sentinel, throws an error on missing command
-        const masters = await client.falkordb.sentinelMasters();
-        const details = extractDetails(masters);
-        if (details.length > 1) {
-            throw new Error('Multiple masters are not supported');
-        }
-        // Connect to the server with the details from sentinel
-        const socketOptions = {
-            ...redisOption.socket,
-            host: details[0]['ip'],
-            port: parseInt(details[0]['port'])
-        };
-        const serverOptions = {
-            ...redisOption,
-            socket: socketOptions
-        };
-        const realClient = (0, redis_1.createClient)(serverOptions);
-        // Set original client as sentinel and server client as client
-        this.#sentinel = client;
-        this.#client = realClient;
-        await realClient
-            .on('error', async (err) => {
-            console.debug('Error on server connection', err);
-            // Disconnect the client to avoid further errors and retries
-            realClient.disconnect();
-            // If error occurs on previous server connection, no need to reconnect
-            if (this.#client !== realClient) {
-                return;
-            }
-            try {
-                await this.connectServer(client, redisOption);
-                console.debug('Connected to server');
-            }
-            catch (e) {
-                console.debug('Error on server reconnect', e);
-                // Forward errors if reconnection fails
-                this.emit('error', err);
-            }
-        })
-            .connect();
-    }
+    #client = new nullClient_1.NullClient();
     static async connect(options) {
         const redisOption = (options ?? {});
         // If the URL is provided, and the protocol is `falkor` replaces it with `redis` for the underline redis client
@@ -78,17 +34,18 @@ class FalkorDB extends events_1.EventEmitter {
         redisOption.modules = {
             falkordb: commands_1.default
         };
-        const client = (0, redis_1.createClient)(redisOption);
-        const falkordb = new FalkorDB(client);
-        await client
+        // Create an empty FalkorDB instance for the redisClient on error event to work
+        const falkordb = new FalkorDB();
+        // Create initial redis single client
+        const redisClient = (0, redis_1.createClient)(redisOption);
+        await redisClient
             .on('error', err => falkordb.emit('error', err)) // Forward errors
             .connect();
-        try {
-            await falkordb.connectServer(client, redisOption);
-        }
-        catch (e) {
-            console.debug('Error in connecting to sentinel, connecting to server directly');
-        }
+        // Create FalkorDB client wrapper
+        const client = await clientFactory(redisClient);
+        await client.init(falkordb);
+        // Set the client to the FalkorDB instance after it was initialized
+        falkordb.#client = client;
         return falkordb;
     }
     selectGraph(graphId) {
@@ -98,16 +55,16 @@ class FalkorDB extends events_1.EventEmitter {
         return this.#client;
     }
     async list() {
-        return this.#client.falkordb.list();
+        return this.#client.list();
     }
     async configGet(configKey) {
-        return this.#client.falkordb.configGet(configKey);
+        return this.#client.configGet(configKey);
     }
     async configSet(configKey, value) {
-        return this.#client.falkordb.configSet(configKey, value);
+        return this.#client.configSet(configKey, value);
     }
     async info(section) {
-        return this.#client.falkordb.info(section);
+        return this.#client.info(section);
     }
     /**
      * Closes the client.

package/dist/src/graph.d.ts

@@ -1,31 +1,27 @@
 import { RedisCommandArgument } from "@redis/client/dist/lib/commands";
-import { RedisClientType, RedisFunctions, RedisScripts } from "redis";
 import { QueryOptions } from "./commands";
 import { QueryReply } from "./commands/QUERY";
-import Commands from "./commands";
 import { ConstraintType, EntityType } from "./commands/CONSTRAINT_CREATE";
+import { Client } from "./clients/client";
 export { ConstraintType, EntityType };
-type GraphReply<T> = Omit<QueryReply, 'headers' | 'data'> & {
+export type GraphReply<T> = Omit<QueryReply, 'headers' | 'data'> & {
     data?: Array<T>;
 };
-export type GraphConnection = RedisClientType<{
-    falkordb: typeof Commands;
-}, RedisFunctions, RedisScripts>;
 export default class Graph {
     #private;
-    constructor(client: GraphConnection, name: string);
+    constructor(client: Client, name: string);
     query<T>(query: RedisCommandArgument, options?: QueryOptions): Promise<GraphReply<T>>;
     roQuery<T>(query: RedisCommandArgument, options?: QueryOptions): Promise<GraphReply<T>>;
-    delete(): Promise<string>;
-    explain(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 | 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(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 | 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>;
+    delete(): Promise<void>;
+    explain(query: string): Promise<any>;
+    profile(query: string): Promise<any>;
     slowLog(): Promise<{
         timestamp: Date;
         command: string;
         query: string;
         took: number;
     }[]>;
-    constraintCreate(constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<"PENDING">;
-    constraintDrop(constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<"OK">;
-    copy(destGraph: string): Promise<"OK">;
+    constraintCreate(constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
+    constraintDrop(constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
+    copy(destGraph: string): Promise<any>;
 }

package/dist/src/graph.js

@@ -20,74 +20,43 @@ var GraphValueTypes;
     GraphValueTypes[GraphValueTypes["MAP"] = 10] = "MAP";
     GraphValueTypes[GraphValueTypes["POINT"] = 11] = "POINT";
 })(GraphValueTypes || (GraphValueTypes = {}));
+// export type GraphConnection = SingleGraphConnection | ClusterGraphConnection;
 class Graph {
     #client;
     #name;
     #metadata;
-    #usePool;
     constructor(client, name) {
         this.#client = client;
         this.#name = name;
-        this.#usePool = !!(this.#client.options?.isolationPoolOptions);
     }
     async query(query, options) {
-        const reply = this.#usePool ?
-            await this.#client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.query(this.#name, query, options, true);
-            })
-            :
-                await this.#client.falkordb.query(this.#name, query, options, true);
+        const reply = await this.#client.query(this.#name, query, options);
         return this.#parseReply(reply);
     }
     async roQuery(query, options) {
-        const reply = this.#usePool ?
-            await this.#client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.roQuery(this.#name, query, options, true);
-            })
-            :
-                await this.#client.falkordb.roQuery(this.#name, query, options, true);
+        const reply = await this.#client.roQuery(this.#name, query, options);
         return this.#parseReply(reply);
     }
     async delete() {
-        if (this.#usePool) {
-            return this.#client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.delete(this.#name);
-            });
-        }
-        return this.#client.falkordb.delete(this.#name);
+        return this.#client.delete(this.#name);
     }
     async explain(query) {
-        if (this.#usePool) {
-            return this.#client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.explain(this.#name, query);
-            });
-        }
-        return this.#client.falkordb.explain(this.#name, query);
+        return this.#client.explain(this.#name, query);
     }
     async profile(query) {
-        if (this.#usePool) {
-            return this.#client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.profile(this.#name, query);
-            });
-        }
-        return this.#client.falkordb.profile(this.#name, query);
+        return this.#client.profile(this.#name, query);
     }
     async slowLog() {
-        if (this.#usePool) {
-            return this.#client.executeIsolated(async (isolatedClient) => {
-                return isolatedClient.falkordb.slowLog(this.#name);
-            });
-        }
-        return this.#client.falkordb.slowLog(this.#name);
+        return this.#client.slowLog(this.#name);
     }
     async constraintCreate(constraintType, entityType, label, ...properties) {
-        return this.#client.falkordb.constraintCreate(this.#name, constraintType, entityType, label, ...properties);
+        return this.#client.constraintCreate(this.#name, constraintType, entityType, label, ...properties);
     }
     async constraintDrop(constraintType, entityType, label, ...properties) {
-        return this.#client.falkordb.constraintDrop(this.#name, constraintType, entityType, label, ...properties);
+        return this.#client.constraintDrop(this.#name, constraintType, entityType, label, ...properties);
     }
     async copy(destGraph) {
-        return this.#client.falkordb.copy(this.#name, destGraph);
+        return this.#client.copy(this.#name, destGraph);
     }
     #setMetadataPromise;
     #updateMetadata() {
@@ -98,9 +67,9 @@ class Graph {
     // DO NOT use directly, use #updateMetadata instead
     async #setMetadata() {
         const [labels, relationshipTypes, propertyKeys] = await Promise.all([
-            this.#client.falkordb.roQuery(this.#name, 'CALL db.labels()'),
-            this.#client.falkordb.roQuery(this.#name, 'CALL db.relationshipTypes()'),
-            this.#client.falkordb.roQuery(this.#name, 'CALL db.propertyKeys()')
+            this.#client.roQuery(this.#name, 'CALL db.labels()'),
+            this.#client.roQuery(this.#name, 'CALL db.relationshipTypes()'),
+            this.#client.roQuery(this.#name, 'CALL db.propertyKeys()')
         ]);
         this.#metadata = {
             labels: this.#cleanMetadataArray(labels.data),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "falkordb",
-  "version": "6.2.0-beta.1",
+  "version": "6.2.0",
   "description": "A FalkorDB javascript library",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -35,7 +35,8 @@
   "devDependencies": {
     "@tsconfig/node14": "^14.1.0",
     "@types/jest": "^29.5.12",
-    "@types/node": "^20.11.28",
+    "@types/lodash": "^4.17.7",
+    "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^7.16.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.57.0",
@@ -45,7 +46,9 @@
   },
   "dependencies": {
     "@redis/client": "^1.6.0",
+    "cluster-key-slot": "1.1.2",
     "generic-pool": "^3.9.0",
+    "lodash": "^4.17.21",
     "redis": "^4.7.0"
   }
 }