falkordb 6.8.0 → 6.9.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { default as Graph } from './src/graph';
-export { ConstraintType, EntityType } from './src/graph';
+export { ConstraintType, EntityType } from './src/enums';
 export { default as FalkorDB } from './src/falkordb';
-export type { FalkorDBOptions } from './src/falkordb';
+export type { FalkorDBOptions } from './src/types';
+export type { QueryParam, QueryParams, QueryOptions, QueryOptionsBackwardCompatible } from './src/types';

package/dist/index.js

@@ -1,10 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FalkorDB = exports.EntityType = exports.ConstraintType = exports.Graph = void 0;
 var graph_1 = require("./src/graph");
-Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return graph_1.default; } });
-var graph_2 = require("./src/graph");
-Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return graph_2.ConstraintType; } });
-Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return graph_2.EntityType; } });
+Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return __importDefault(graph_1).default; } });
+var enums_1 = require("./src/enums");
+Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return enums_1.ConstraintType; } });
+Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return enums_1.EntityType; } });
 var falkordb_1 = require("./src/falkordb");
-Object.defineProperty(exports, "FalkorDB", { enumerable: true, get: function () { return falkordb_1.default; } });
+Object.defineProperty(exports, "FalkorDB", { enumerable: true, get: function () { return __importDefault(falkordb_1).default; } });

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

@@ -1,10 +1,7 @@
 import { RedisArgument } from "@redis/client";
-import { QueryOptions } from "../commands";
-import { ConstraintType, EntityType } from "../graph";
+import { ConstraintType, EntityType } from "../enums";
 import FalkorDB from "../falkordb";
-import { SingleGraphConnection } from "./single";
-import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
-import { UdfListReply } from "../commands/UDF_LIST";
+import type { MemoryUsageOptions, MemoryUsageReply, QueryOptions, SingleGraphConnection, SlowLogReply, UdfListReply } from "../types";
 export interface Client {
     init(falkordb: FalkorDB): Promise<void>;
     list(): Promise<Array<string>>;
@@ -19,19 +16,14 @@ 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: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<any>;
+    query<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number): Promise<any>;
     profile<T>(graph: string, query: RedisArgument): Promise<any>;
-    roQuery<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<any>;
+    roQuery<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number): Promise<any>;
     copy<T>(srcGraph: string, destGraph: string): Promise<any>;
     delete(graph: string): Promise<void>;
     explain(graph: string, query: string): Promise<any>;
     memoryUsage(graph: string, options?: MemoryUsageOptions): Promise<MemoryUsageReply>;
-    slowLog(graph: string): Promise<{
-        timestamp: Date;
-        command: string;
-        query: string;
-        took: number;
-    }[]>;
+    slowLog(graph: string): Promise<SlowLogReply>;
     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>;

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

@@ -1,15 +1,10 @@
 import { Client } from "./client";
-import { ConstraintType, EntityType } from "../graph";
+import { ConstraintType, EntityType } from "../enums";
 import { RedisArgument, RedisFunctions, RedisScripts } from "@redis/client";
-import commands, { QueryOptions } from "../commands";
-import { RedisClusterType } from "@redis/client";
+import commands from "../commands";
 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, 2>;
+import type { ClusterGraphConnection, MemoryUsageOptions, MemoryUsageReply, QueryOptions, SingleGraphConnection, UdfListReply } from "../types";
+export type { ClusterGraphConnection };
 /**
  * A client that connects to a Redis Cluster.
  */
@@ -20,7 +15,7 @@ export declare class Cluster implements Client {
         falkordb: typeof commands;
     }, RedisFunctions, RedisScripts, 2, {}>>;
     init(falkordb: FalkorDB): Promise<void>;
-    query<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<{
+    query<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -29,7 +24,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: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<{
+    roQuery<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -42,7 +37,7 @@ export declare class Cluster implements Client {
     explain(graph: string, query: string): Promise<string[]>;
     list(): Promise<Array<string>>;
     stubs(): Promise<Array<string>>;
-    configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
+    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">;

package/dist/src/clients/cluster.js

@@ -1,8 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cluster = void 0;
 const client_1 = require("@redis/client");
-const lodash = require("lodash");
+const lodash = __importStar(require("lodash"));
 /**
  * A client that connects to a Redis Cluster.
  */
@@ -32,12 +65,12 @@ class Cluster {
             .connect();
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async query(graph, query, options, compact = true) {
-        return this.#client.falkordb.query(graph, query, options, compact);
+    async query(graph, query, options, compact = true, version) {
+        return this.#client.falkordb.query(graph, query, options, compact, version);
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async roQuery(graph, query, options, compact = true) {
-        return this.#client.falkordb.roQuery(graph, query, options, compact);
+    async roQuery(graph, query, options, compact = true, version) {
+        return this.#client.falkordb.roQuery(graph, query, options, compact, version);
     }
     async delete(graph) {
         const reply = this.#client.falkordb.delete(graph);

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

@@ -1,11 +1,8 @@
 import { RedisArgument } from "@redis/client";
-import { QueryOptions } from "../commands";
 import FalkorDB from "../falkordb";
-import { ConstraintType, EntityType } from "../graph";
+import { ConstraintType, EntityType } from "../enums";
 import { Client } from "./client";
-import { SingleGraphConnection } from "./single";
-import { MemoryUsageOptions, MemoryUsageReply } from "../commands/MEMORY_USAGE";
-import { UdfListReply } from "../commands/UDF_LIST";
+import type { MemoryUsageOptions, MemoryUsageReply, QueryOptions, SingleGraphConnection, SlowLogReply, UdfListReply } from "../types";
 /**
  * The `NullClient` class is a placeholder implementation of the `Client` interface.
  *
@@ -31,12 +28,7 @@ export declare class NullClient implements Client {
     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;
-    }[]>;
+    slowLog(_graph: string): Promise<SlowLogReply>;
     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>;

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

@@ -1,8 +1,39 @@
 import { Single } from "./single";
 import FalkorDB from "../falkordb";
+import type { SingleGraphConnection } from "../types";
+import type { RunOptions } from "./single";
+export interface SentinelOptions {
+    /**
+     * Resend write commands to the new master when the connection is lost while
+     * waiting for their reply. The old master may have already run them, so a
+     * write can be applied twice. Read-only commands, and commands the server
+     * certainly did not run, are always resent.
+     * @default false
+     */
+    retryWritesOnConnectionLoss?: boolean;
+}
 export declare class Sentinel extends Single {
     private sentinelClient;
+    private redisOption;
+    private falkordb?;
+    private ready;
+    private closed;
+    private recovery;
+    private readonly retryWritesOnConnectionLoss;
+    constructor(client: SingleGraphConnection, options?: SentinelOptions);
     init(falkordb: FalkorDB): Promise<void>;
+    /**
+     * Runs a command on the current master. If the master connection is lost, or
+     * the node was demoted, waits for the new master and resends the command
+     * there when that is safe: the command certainly did not run, it is
+     * read-only, or `retryWritesOnConnectionLoss` is set.
+     */
+    protected run<T>(fn: (client: SingleGraphConnection) => Promise<T>, { readOnly }?: RunOptions): Promise<T>;
+    /**
+     * Re-discovers the master and reconnects, retrying with backoff until it
+     * succeeds or the client is closed.
+     */
+    private recover;
     /**
      * Connect to the server using the details from sentinel server
      * Register error event to reconnect on error from the sentinel server

package/dist/src/clients/sentinel.js

@@ -3,6 +3,78 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sentinel = void 0;
 const single_1 = require("./single");
 const client_1 = require("@redis/client");
+// How many times a command is resent after losing its connection to the master
+const MAX_COMMAND_RETRIES = 3;
+// Backoff between attempts to re-discover the master
+const MIN_RECOVERY_DELAY_MS = 100;
+const MAX_RECOVERY_DELAY_MS = 2000;
+// How long a demoted master's connection may take to finish in-flight commands
+const CLOSE_TIMEOUT_MS = 5000;
+// Connections destroyed while commands may still have been in flight, whose
+// DisconnectsClientError rejections therefore have an unknown outcome
+const forceClosed = new WeakSet();
+const RETRYABLE_SOCKET_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EPIPE",
+    "ETIMEDOUT",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+]);
+/**
+ * Whether the command certainly did not run on the server, so it is safe to
+ * resend it to the current master.
+ */
+function wasNotExecuted(err, client) {
+    if (err instanceof client_1.DisconnectsClientError && forceClosed.has(client)) {
+        return false;
+    }
+    if (err instanceof client_1.ErrorReply) {
+        // The node was demoted to a replica while the command was queued or blocked
+        return /^(READONLY|UNBLOCKED)\b/.test(err.message);
+    }
+    // Rejected before being sent: on a closed client, or flushed unsent when a
+    // dead master connection is destroyed (see dropClient)
+    return (err instanceof client_1.ClientClosedError ||
+        err instanceof client_1.ClientOfflineError ||
+        err instanceof client_1.DisconnectsClientError);
+}
+/**
+ * Whether the connection dropped while waiting for the reply, so the command
+ * may or may not have run on the server.
+ */
+function isConnectionLost(err, client) {
+    return (err instanceof client_1.SocketClosedUnexpectedlyError ||
+        (err instanceof client_1.DisconnectsClientError && forceClosed.has(client)) ||
+        RETRYABLE_SOCKET_CODES.has(err?.code ?? ""));
+}
+/**
+ * Stops using a master connection. Commands still unsent are rejected with
+ * DisconnectsClientError, which run() resends.
+ */
+function dropClient(client) {
+    if (client.isReady) {
+        // The connection is alive (e.g. the node was demoted): let in-flight
+        // commands get their replies, so none is left with an unknown outcome.
+        // If they take too long, give up on them: their outcome is then unknown.
+        const forceClose = () => {
+            forceClosed.add(client);
+            client.destroy();
+        };
+        const timer = setTimeout(forceClose, CLOSE_TIMEOUT_MS);
+        timer.unref?.();
+        client
+            .close()
+            .catch(forceClose)
+            .finally(() => clearTimeout(timer));
+    }
+    else {
+        // The socket is gone. Destroy once node-redis has failed the in-flight
+        // commands with the socket error, so that DisconnectsClientError only
+        // reaches commands that were never sent.
+        queueMicrotask(() => client.destroy());
+    }
+}
 function extractDetails(masters) {
     const allDetails = [];
     for (const master of masters) {
@@ -16,15 +88,99 @@ function extractDetails(masters) {
 }
 class Sentinel extends single_1.Single {
     sentinelClient;
-    init(falkordb) {
-        const redisOption = (this.client.options ?? {});
-        return this.tryConnectSentinelServer(this.client, redisOption, falkordb);
+    redisOption = {};
+    falkordb;
+    // Set once the first master connection is up; recovery only runs after that
+    ready = false;
+    closed = false;
+    // Pending re-discovery of the master, shared by every command waiting on it
+    recovery = null;
+    retryWritesOnConnectionLoss;
+    constructor(client, options = {}) {
+        super(client);
+        this.retryWritesOnConnectionLoss = options.retryWritesOnConnectionLoss ?? false;
+    }
+    async init(falkordb) {
+        this.redisOption = (this.client.options ?? {});
+        this.falkordb = falkordb;
+        await this.tryConnectSentinelServer(this.client, this.redisOption, falkordb);
+        this.ready = true;
+    }
+    /**
+     * Runs a command on the current master. If the master connection is lost, or
+     * the node was demoted, waits for the new master and resends the command
+     * there when that is safe: the command certainly did not run, it is
+     * read-only, or `retryWritesOnConnectionLoss` is set.
+     */
+    async run(fn, { readOnly = false } = {}) {
+        for (let attempt = 0;; attempt++) {
+            if (this.recovery) {
+                await this.recovery;
+            }
+            const client = this.client;
+            try {
+                return await fn(client);
+            }
+            catch (err) {
+                const notExecuted = wasNotExecuted(err, client);
+                const connectionLost = isConnectionLost(err, client);
+                if (this.closed || (!notExecuted && !connectionLost)) {
+                    throw err;
+                }
+                // Switch to the new master even when this command is not resent
+                // e.g. READONLY: the connection is fine but points to a replica now
+                if (this.client === client) {
+                    this.recover(client);
+                }
+                const resend = notExecuted || readOnly || this.retryWritesOnConnectionLoss;
+                if (!resend || attempt >= MAX_COMMAND_RETRIES) {
+                    throw err;
+                }
+                console.debug("Command failed on master connection, retrying", err);
+            }
+        }
+    }
+    /**
+     * Re-discovers the master and reconnects, retrying with backoff until it
+     * succeeds or the client is closed.
+     */
+    recover(failedClient) {
+        if (this.recovery) {
+            return this.recovery;
+        }
+        // Stop sending to the old master. Commands it rejects unsent are resent
+        // by run() once the new master is up.
+        dropClient(failedClient);
+        this.recovery = (async () => {
+            for (let attempt = 0; !this.closed; attempt++) {
+                try {
+                    await this.tryConnectSentinelServer(this.sentinelClient, this.redisOption, this.falkordb);
+                    console.debug("Connected to server");
+                    return;
+                }
+                catch (e) {
+                    console.debug("Error on server reconnect", e);
+                    // Emitting "error" without a listener throws, which would end recovery
+                    if (this.falkordb?.listenerCount("error")) {
+                        this.falkordb.emit("error", e);
+                    }
+                    const delay = Math.min(MIN_RECOVERY_DELAY_MS * 2 ** attempt, MAX_RECOVERY_DELAY_MS);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+            throw new client_1.ClientClosedError();
+        })().finally(() => {
+            this.recovery = null;
+        });
+        // Avoid an unhandled rejection when no command is waiting on it
+        this.recovery.catch(() => { });
+        return this.recovery;
     }
     /**
      * 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) {
+    async tryConnectSentinelServer(client, redisOption, _falkordb) {
         // TODO support multi sentinels
         const masters = await client.falkordb.sentinelMasters();
         const details = extractDetails(masters);
@@ -46,31 +202,30 @@ class Sentinel extends single_1.Single {
         this.sentinelClient = client;
         // 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();
+        try {
+            await realClient
+                .on("error", (err) => {
+                console.debug("Error on server connection", err);
+                // Errors on a previous server connection, or before the first
+                // connection is up (init() reports those), need no recovery
+                if (this.client !== realClient || !this.ready || this.recovery) {
+                    dropClient(realClient);
+                    return;
+                }
+                this.recover(realClient);
+            })
+                .connect();
+        }
+        catch (err) {
+            realClient.destroy();
+            throw err;
+        }
     }
     quit() {
         return this.disconnect();
     }
     async disconnect() {
+        this.closed = true;
         const promises = [super.disconnect()];
         if (this.sentinelClient) {
             const reply = this.sentinelClient.disconnect();

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

@@ -1,19 +1,23 @@
 import { Client } from "./client";
-import { ConstraintType, EntityType } from "../graph";
-import { RedisArgument, RedisFunctions, RedisScripts } from "@redis/client";
-import commands, { QueryOptions } from "../commands";
-import { RedisClientType } from "@redis/client";
+import { ConstraintType, EntityType } from "../enums";
+import { RedisArgument } 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, 2>;
+import type { MemoryUsageOptions, MemoryUsageReply, QueryOptions, SingleGraphConnection, UdfListReply } from "../types";
+export type { SingleGraphConnection };
+export interface RunOptions {
+    /** The command does not change data, so running it twice is harmless */
+    readOnly?: boolean;
+}
 export declare class Single implements Client {
     protected client: SingleGraphConnection;
     constructor(client: SingleGraphConnection);
     init(_falkordb: FalkorDB): Promise<void>;
-    query<_T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<{
+    /**
+     * Runs a command against the underlying connection.
+     * Subclasses override it to add recovery, e.g. retrying on a new master.
+     */
+    protected run<T>(fn: (client: SingleGraphConnection) => Promise<T>, _options?: RunOptions): Promise<T>;
+    query<_T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -22,7 +26,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: RedisArgument, options?: QueryOptions, compact?: boolean): Promise<{
+    roQuery<_T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -36,7 +40,7 @@ export declare class Single implements Client {
     profile<_T>(graph: string, query: string): Promise<string[]>;
     list(): Promise<string[]>;
     stubs(): Promise<string[]>;
-    configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
+    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<{

package/dist/src/clients/single.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Single = void 0;
+const READ_ONLY = { readOnly: true };
 class Single {
     client;
     constructor(client) {
@@ -9,66 +10,73 @@ class Single {
     init(_falkordb) {
         return Promise.resolve();
     }
-    async query(graph, query, options, compact = true) {
-        return await this.client.falkordb.query(graph, query, options, compact);
+    /**
+     * Runs a command against the underlying connection.
+     * Subclasses override it to add recovery, e.g. retrying on a new master.
+     */
+    run(fn, _options = {}) {
+        return fn(this.client);
     }
-    async roQuery(graph, query, options, compact = true) {
-        return await this.client.falkordb.roQuery(graph, query, options, compact);
+    async query(graph, query, options, compact = true, version) {
+        return await this.run((client) => client.falkordb.query(graph, query, options, compact, version));
+    }
+    async roQuery(graph, query, options, compact = true, version) {
+        return await this.run((client) => client.falkordb.roQuery(graph, query, options, compact, version), READ_ONLY);
     }
     async delete(graph) {
-        const reply = this.client.falkordb.delete(graph);
+        const reply = this.run((client) => client.falkordb.delete(graph));
         return reply.then(() => { });
     }
     async explain(graph, query) {
-        return this.client.falkordb.explain(graph, query);
+        return this.run((client) => client.falkordb.explain(graph, query), READ_ONLY);
     }
     async profile(graph, query) {
-        return this.client.falkordb.profile(graph, query);
+        return this.run((client) => client.falkordb.profile(graph, query));
     }
     async list() {
-        return this.client.falkordb.list();
+        return this.run((client) => client.falkordb.list(), READ_ONLY);
     }
     async stubs() {
-        return this.client.falkordb.stubs();
+        return this.run((client) => client.falkordb.stubs());
     }
     async configGet(configKey) {
-        return this.client.falkordb.configGet(configKey);
+        return this.run((client) => client.falkordb.configGet(configKey), READ_ONLY);
     }
     async configSet(configKey, value) {
-        const reply = this.client.falkordb.configSet(configKey, value);
+        const reply = this.run((client) => client.falkordb.configSet(configKey, value));
         return reply.then(() => { });
     }
     async info(section) {
-        return this.client.falkordb.info(section);
+        return this.run((client) => client.falkordb.info(section), READ_ONLY);
     }
     async slowLog(graph) {
-        return this.client.falkordb.slowLog(graph);
+        return this.run((client) => client.falkordb.slowLog(graph), READ_ONLY);
     }
     async memoryUsage(graph, options) {
-        return this.client.falkordb.memoryUsage(graph, options);
+        return this.run((client) => client.falkordb.memoryUsage(graph, options), READ_ONLY);
     }
     async constraintCreate(graph, constraintType, entityType, label, ...properties) {
-        const reply = this.client.falkordb.constraintCreate(graph, constraintType, entityType, label, ...properties);
+        const reply = this.run((client) => 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);
+        const reply = this.run((client) => 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);
+        return this.run((client) => client.falkordb.udfLoad(name, script, replace));
     }
     async udfList(lib, withCode = false) {
-        return this.client.falkordb.udfList(lib, withCode);
+        return this.run((client) => client.falkordb.udfList(lib, withCode), READ_ONLY);
     }
     async udfFlush() {
-        return this.client.falkordb.udfFlush();
+        return this.run((client) => client.falkordb.udfFlush());
     }
     async udfDelete(lib) {
-        return this.client.falkordb.udfDelete(lib);
+        return this.run((client) => client.falkordb.udfDelete(lib));
     }
     async copy(srcGraph, destGraph) {
-        return this.client.falkordb.copy(srcGraph, destGraph);
+        return this.run((client) => client.falkordb.copy(srcGraph, destGraph));
     }
     quit() {
         return this.disconnect();

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

@@ -1,10 +1,6 @@
 import { CommandParser } from '@redis/client';
+import type { ConfigItem } from '../types';
 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(reply: unknown): ConfigItem | Array<ConfigItem>;
-export {};