falkordb 6.9.2 → 6.9.3

package/dist/src/commands/QUERY.js

@@ -8,7 +8,11 @@ const _1 = require(".");
 const errors_1 = require("../errors");
 exports.FIRST_KEY_INDEX = 1;
 function parseCommand(parser, graph, query, options, compact, version) {
-    const args = (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact, version);
+    // The graph is pushed as a key so that cluster clients route the command
+    // to the graph's shard rather than a random node
+    const [, ...args] = (0, _1.pushQueryArguments)([], graph, query, options, compact, version);
+    parser.push('GRAPH.QUERY');
+    parser.pushKey(graph);
     parser.push(...args);
 }
 function transformArguments(graph, query, options, compact, version) {
@@ -23,7 +27,8 @@ function transformReply(reply) {
     const [first, second] = reply;
     if (first instanceof Error) {
         if (VERSION_MISMATCH.test(first.message)) {
-            throw new errors_1.SchemaVersionMismatchError(second);
+            // A string when integers are returned as their exact digits
+            throw new errors_1.SchemaVersionMismatchError(Number(second));
         }
         throw first;
     }

package/dist/src/commands/RO_QUERY.js

@@ -8,7 +8,11 @@ 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, version) {
-    const args = (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact, version);
+    // The graph is pushed as a key so that cluster clients route the command
+    // to the graph's shard rather than a random node
+    const [, ...args] = (0, _1.pushQueryArguments)([], graph, query, options, compact, version);
+    parser.push('GRAPH.RO_QUERY');
+    parser.pushKey(graph);
     parser.push(...args);
 }
 function transformArguments(graph, query, options, compact, version) {

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

@@ -1,6 +1,6 @@
 import { CommandParser } from '@redis/client';
 import type { SlowLogRawReply, SlowLogReply } from '../types';
-export declare const IS_READ_ONLY = true;
+export declare const IS_READ_ONLY = false;
 export declare const FIRST_KEY_INDEX = 1;
 export declare function parseCommand(parser: CommandParser, key: string): void;
 export declare function transformArguments(key: string): string[];

package/dist/src/commands/SLOWLOG.js

@@ -4,7 +4,9 @@ exports.FIRST_KEY_INDEX = exports.IS_READ_ONLY = void 0;
 exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
-exports.IS_READ_ONLY = true;
+// Each node keeps its own slowlog and replicas don't record the queries their
+// master ran, so this is sent to the master like a write
+exports.IS_READ_ONLY = false;
 exports.FIRST_KEY_INDEX = 1;
 function parseCommand(parser, key) {
     parser.push('GRAPH.SLOWLOG');

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

@@ -0,0 +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(reply: unknown): 'OK';

package/dist/src/commands/SLOWLOG_RESET.js

@@ -0,0 +1,19 @@
+"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;
+// GRAPH.SLOWLOG key RESET
+function parseCommand(parser, key) {
+    parser.push('GRAPH.SLOWLOG');
+    parser.pushKey(key);
+    parser.push('RESET');
+}
+function transformArguments(key) {
+    return ['GRAPH.SLOWLOG', key, 'RESET'];
+}
+function transformReply(reply) {
+    return reply;
+}

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

@@ -19,8 +19,9 @@ 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 * as SLOWLOG_RESET from './SLOWLOG_RESET';
 import { RedisArgument } from '@redis/client';
-import type { QueryOptionsBackwardCompatible } from '../types';
+import type { QueryOptionsBackwardCompatible, QueryParams } from '../types';
 declare const _default: {
     CONFIG_GET: typeof CONFIG_GET;
     configGet: typeof CONFIG_GET;
@@ -64,8 +65,16 @@ declare const _default: {
     udfFlush: typeof UDF_FLUSH;
     UDF_DELETE: typeof UDF_DELETE;
     udfDelete: typeof UDF_DELETE;
+    SLOWLOG_RESET: typeof SLOWLOG_RESET;
+    slowLogReset: typeof SLOWLOG_RESET;
 };
 export default _default;
 export type { QueryOptions, QueryOptionsBackwardCompatible, QueryParam, QueryParams } from '../types';
 export declare function pushQueryArguments(args: Array<RedisArgument>, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): Array<RedisArgument>;
+/**
+ * Prefixes the query with a `CYPHER` header carrying the params. Without
+ * params the query is returned unchanged.
+ */
+export declare function withParamsHeader<T extends RedisArgument>(query: T, params?: QueryParams): T | string;
+export declare function escapeIdentifier(name: string, kind: string): string;
 export type { UdfListReply, UdfLibraryEntry } from '../types';

package/dist/src/commands/index.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pushQueryArguments = pushQueryArguments;
+exports.withParamsHeader = withParamsHeader;
+exports.escapeIdentifier = escapeIdentifier;
 const CONFIG_GET = __importStar(require("./CONFIG_GET"));
 const CONFIG_SET = __importStar(require("./CONFIG_SET"));
 const DELETE = __importStar(require("./DELETE"));
@@ -55,6 +57,9 @@ const UDF_LOAD = __importStar(require("./UDF_LOAD"));
 const UDF_LIST = __importStar(require("./UDF_LIST"));
 const UDF_FLUSH = __importStar(require("./UDF_FLUSH"));
 const UDF_DELETE = __importStar(require("./UDF_DELETE"));
+const SLOWLOG_RESET = __importStar(require("./SLOWLOG_RESET"));
+const node_util_1 = require("node:util");
+const lodash_1 = require("lodash");
 exports.default = {
     CONFIG_GET,
     configGet: CONFIG_GET,
@@ -98,6 +103,8 @@ exports.default = {
     udfFlush: UDF_FLUSH,
     UDF_DELETE,
     udfDelete: UDF_DELETE,
+    SLOWLOG_RESET,
+    slowLogReset: SLOWLOG_RESET,
 };
 function pushQueryArguments(args, graph, query, options, compact, version) {
     args.push(graph);
@@ -106,9 +113,7 @@ function pushQueryArguments(args, graph, query, options, compact, version) {
         pushTimeout(args, options);
     }
     else {
-        args.push(options?.params ?
-            `CYPHER ${queryParamsToString(options.params)} ${query}` :
-            query);
+        args.push(withParamsHeader(query, options?.params));
         if (options?.TIMEOUT !== undefined) {
             pushTimeout(args, options.TIMEOUT);
         }
@@ -121,16 +126,43 @@ function pushQueryArguments(args, graph, query, options, compact, version) {
     }
     return args;
 }
+/**
+ * Prefixes the query with a `CYPHER` header carrying the params. Without
+ * params the query is returned unchanged.
+ */
+function withParamsHeader(query, params) {
+    return params ? `CYPHER ${queryParamsToString(params)} ${query}` : query;
+}
 function pushTimeout(args, timeout) {
     args.push('TIMEOUT', timeout.toString());
 }
 function queryParamsToString(params) {
     const parts = [];
     for (const [key, value] of Object.entries(params)) {
-        parts.push(`${key}=${queryParamToString(value)}`);
+        parts.push(`${escapeIdentifier(key, 'parameter name')}=${queryParamToString(value)}`);
     }
     return parts.join(' ');
 }
+// Wraps a name (a parameter, map key, label or property) in backticks so that
+// names which are not bare identifiers (e.g. `@type`, `Product Type`) are
+// accepted by the parser. FalkorDB does not support escaped backticks inside
+// identifiers, so names containing one are rejected, as are empty names
+function escapeIdentifier(name, kind) {
+    if (name === '') {
+        throw new TypeError(`Cypher ${kind} cannot be empty`);
+    }
+    if (name.includes('`')) {
+        throw new TypeError(`Cypher ${kind} cannot contain a backtick: ${JSON.stringify(name)} ` +
+            '(FalkorDB does not support escaped backticks in identifiers)');
+    }
+    return `\`${name}\``;
+}
+// Names the type of a non-plain object for error messages, e.g. `Date` or a class name
+function objectTypeName(value) {
+    const proto = Object.getPrototypeOf(value);
+    const name = Object.hasOwn(proto, 'constructor') ? proto.constructor?.name : undefined;
+    return name || 'object with a custom prototype';
+}
 function queryParamToString(param) {
     if (param === null) {
         return 'null';
@@ -139,20 +171,36 @@ function queryParamToString(param) {
         case 'string':
             return `"${param.replace(/["\\]/g, '\\$&')}"`;
         case 'number':
+            if (!Number.isFinite(param)) {
+                throw new TypeError(`Unsupported param value ${param}: only finite numbers are supported`);
+            }
+            return param.toString();
+        case 'bigint':
         case 'boolean':
             return param.toString();
+        case 'object':
+            break;
+        default:
+            throw new TypeError(`Unsupported param type ${typeof param}`);
     }
     if (Array.isArray(param)) {
         return `[${param.map(queryParamToString).join(',')}]`;
     }
-    else if (typeof param === 'object') {
-        const body = [];
-        for (const [key, value] of Object.entries(param)) {
-            body.push(`${key}:${queryParamToString(value)}`);
-        }
-        return `{${body.join(',')}}`;
+    // The checks below also recognise values from another realm (e.g. a `vm`
+    // context), where `instanceof` and prototype identity do not hold
+    if (node_util_1.types.isTypedArray(param)) {
+        // Typed arrays (e.g. Float32Array vectors) are sent as lists
+        return `[${Array.from(param, queryParamToString).join(',')}]`;
     }
-    else {
-        throw new TypeError(`Unexpected param type ${typeof param} ${param}`);
+    // Only plain objects are sent as maps: any other object (a class instance,
+    // Date, Map, ...) would lose its meaning when reduced to its own properties
+    if (!(0, lodash_1.isPlainObject)(param)) {
+        throw new TypeError(`Unsupported param type ${objectTypeName(param)}: ` +
+            'convert it to a plain object or another supported value first');
+    }
+    const body = [];
+    for (const [key, value] of Object.entries(param)) {
+        body.push(`${escapeIdentifier(key, 'map key')}:${queryParamToString(value)}`);
     }
+    return `{${body.join(',')}}`;
 }

package/dist/src/entities.d.ts

@@ -0,0 +1,19 @@
+import type { GraphEdge, GraphNode, GraphPath } from "./types";
+/** The node as a Cypher pattern, e.g. `(:Person{name:"Alice"})` */
+export declare function nodeToString(node: GraphNode): string;
+/** The edge as a Cypher pattern, e.g. `()-[:KNOWS{since:2020}]->()` */
+export declare function edgeToString(edge: GraphEdge): string;
+/**
+ * The path as node and edge ids, each edge pointing the way it runs,
+ * e.g. `<(0)-[0]->(1)<-[1]-(2)>`
+ */
+export declare function pathToString(path: GraphPath): string;
+/** Whether two nodes have the same id, the same labels in order and equal properties */
+export declare function nodesEqual(a: GraphNode, b: GraphNode): boolean;
+/**
+ * Whether two edges are the same edge: equal ids, or else the same endpoints,
+ * relationship type and properties
+ */
+export declare function edgesEqual(a: GraphEdge, b: GraphEdge): boolean;
+/** Whether two paths have equal nodes and edges, in order */
+export declare function pathsEqual(a: GraphPath, b: GraphPath): boolean;

package/dist/src/entities.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeToString = nodeToString;
+exports.edgeToString = edgeToString;
+exports.pathToString = pathToString;
+exports.nodesEqual = nodesEqual;
+exports.edgesEqual = edgesEqual;
+exports.pathsEqual = pathsEqual;
+/**
+ * Helpers for the nodes, edges and paths in query results, which are plain
+ * objects. They match the string forms and equality of the Python client's
+ * `Node`, `Edge` and `Path` classes.
+ */
+const lodash_1 = require("lodash");
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+// A label, relationship type or property key, quoted when it is not a plain
+// identifier, as the query would write it. FalkorDB cannot parse a backtick
+// inside a name, so no name it returns has one; should one appear anyway, it
+// is doubled as openCypher escapes it, since this only formats a value for
+// display and should not throw.
+function nameToString(name) {
+    return IDENTIFIER.test(name) ? name : `\`${name.replace(/`/g, "``")}\``;
+}
+function valueToString(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string") {
+        return `"${value.replace(/["\\]/g, "\\$&")}"`;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(valueToString).join(",")}]`;
+    }
+    // Also maps with a null prototype or from another realm (e.g. node:vm)
+    if ((0, lodash_1.isPlainObject)(value)) {
+        const entries = Object.entries(value).map(([key, item]) => `${nameToString(key)}:${valueToString(item)}`);
+        return `{${entries.join(",")}}`;
+    }
+    // Numbers, booleans and dates and times (Temporal values)
+    return String(value);
+}
+// Properties sorted by key, e.g. `{age:30,name:"Alice"}`, or "" when there are none
+function propertiesToString(properties) {
+    const keys = Object.keys(properties).sort();
+    if (keys.length === 0)
+        return "";
+    const entries = keys.map((key) => `${nameToString(key)}:${valueToString(properties[key])}`);
+    return `{${entries.join(",")}}`;
+}
+/** The node as a Cypher pattern, e.g. `(:Person{name:"Alice"})` */
+function nodeToString(node) {
+    const labels = node.labels.map((label) => `:${nameToString(label)}`).join("");
+    return `(${labels}${propertiesToString(node.properties)})`;
+}
+/** The edge as a Cypher pattern, e.g. `()-[:KNOWS{since:2020}]->()` */
+function edgeToString(edge) {
+    const type = edge.relationshipType ? `:${nameToString(edge.relationshipType)}` : "";
+    return `()-[${type}${propertiesToString(edge.properties)}]->()`;
+}
+/**
+ * The path as node and edge ids, each edge pointing the way it runs,
+ * e.g. `<(0)-[0]->(1)<-[1]-(2)>`
+ */
+function pathToString(path) {
+    let result = "<";
+    path.edges.forEach((edge, i) => {
+        const node = path.nodes[i];
+        result += `(${node.id})`;
+        result += edge.sourceId === node.id ? `-[${edge.id}]->` : `<-[${edge.id}]-`;
+    });
+    return `${result}(${path.nodes[path.edges.length]?.id})>`;
+}
+function valuesEqual(a, b) {
+    // Object.is also treats two NaN as equal
+    if (a === b || Object.is(a, b))
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+        return false;
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return (Array.isArray(a) &&
+            Array.isArray(b) &&
+            a.length === b.length &&
+            a.every((item, i) => valuesEqual(item, b[i])));
+    }
+    // Dates and times (Temporal values) keep their fields in internal slots
+    if (!(0, lodash_1.isPlainObject)(a) || !(0, lodash_1.isPlainObject)(b)) {
+        return (!(0, lodash_1.isPlainObject)(a) &&
+            !(0, lodash_1.isPlainObject)(b) &&
+            a.constructor === b.constructor &&
+            String(a) === String(b));
+    }
+    const keys = Object.keys(a);
+    return (keys.length === Object.keys(b).length &&
+        keys.every((key) => Object.hasOwn(b, key) &&
+            valuesEqual(a[key], b[key])));
+}
+/** Whether two nodes have the same id, the same labels in order and equal properties */
+function nodesEqual(a, b) {
+    return (a.id === b.id &&
+        valuesEqual(a.labels, b.labels) &&
+        valuesEqual(a.properties, b.properties));
+}
+/**
+ * Whether two edges are the same edge: equal ids, or else the same endpoints,
+ * relationship type and properties
+ */
+function edgesEqual(a, b) {
+    if (a.id === b.id)
+        return true;
+    return (a.sourceId === b.sourceId &&
+        a.destinationId === b.destinationId &&
+        a.relationshipType === b.relationshipType &&
+        valuesEqual(a.properties, b.properties));
+}
+/** Whether two paths have equal nodes and edges, in order */
+function pathsEqual(a, b) {
+    return (a.nodes.length === b.nodes.length &&
+        a.edges.length === b.edges.length &&
+        a.nodes.every((node, i) => nodesEqual(node, b.nodes[i])) &&
+        a.edges.every((edge, i) => edgesEqual(edge, b.edges[i])));
+}

package/dist/src/execution-plan.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Structured views of the plans returned by `GRAPH.EXPLAIN` and
+ * `GRAPH.PROFILE`, which describe one operation per line and convey nesting
+ * by indentation:
+ *
+ *     Results
+ *         Project
+ *             Conditional Traverse | (a)->(b)
+ *                 Node By Label Scan | (a:A)
+ *
+ * Profile lines also end with the operation's runtime statistics, e.g.
+ * `| Records produced: 4, Execution time: 0.001200 ms`.
+ */
+/** A single operation of an execution plan and the operations feeding it. */
+export declare class Operation {
+    /** The operation's name, e.g. `Conditional Traverse` */
+    readonly name: string;
+    /** What follows the `|` on the plan line, e.g. `(a)->(b)`, if anything */
+    readonly args?: string;
+    /** How many records the operation produced (profile only) */
+    readonly recordsProduced?: number;
+    /** How long the operation ran, in milliseconds (profile only) */
+    readonly executionTime?: number;
+    /** The operations feeding this one, in plan order */
+    readonly children: Operation[];
+    constructor(name: string, args?: string, recordsProduced?: number, executionTime?: number);
+    /** Parses one plan line, ignoring its indentation. */
+    static fromLine(line: string): Operation;
+    /** The operation as it appears in an explain plan, e.g. `Filter` */
+    toString(): string;
+}
+/** The operation tree of a query, as returned by `Graph.explain`/`Graph.profile`. */
+export declare class ExecutionPlan implements Iterable<Operation> {
+    /** The plan lines exactly as the server returned them */
+    readonly steps: readonly string[];
+    /** The operation producing the query's result */
+    readonly root: Operation;
+    constructor(steps: readonly string[]);
+    /** All operations named `name`, in plan order. */
+    collectOperations(name: string): Operation[];
+    /** Iterates over every operation, parents before their children. */
+    [Symbol.iterator](): Iterator<Operation>;
+    /** The plan as indented lines, without profile statistics. */
+    toString(): string;
+}

package/dist/src/execution-plan.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Structured views of the plans returned by `GRAPH.EXPLAIN` and
+ * `GRAPH.PROFILE`, which describe one operation per line and convey nesting
+ * by indentation:
+ *
+ *     Results
+ *         Project
+ *             Conditional Traverse | (a)->(b)
+ *                 Node By Label Scan | (a:A)
+ *
+ * Profile lines also end with the operation's runtime statistics, e.g.
+ * `| Records produced: 4, Execution time: 0.001200 ms`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionPlan = exports.Operation = void 0;
+const INDENT = "    ";
+// Matched against the text after a line's last `|` only: anchored at both
+// ends so it runs in linear time on any input
+const PROFILE_STATS = /^\s*Records produced: (\d+),\s*Execution time: (\d+(?:\.\d+)?) ms$/;
+/** A single operation of an execution plan and the operations feeding it. */
+class Operation {
+    /** The operation's name, e.g. `Conditional Traverse` */
+    name;
+    /** What follows the `|` on the plan line, e.g. `(a)->(b)`, if anything */
+    args;
+    /** How many records the operation produced (profile only) */
+    recordsProduced;
+    /** How long the operation ran, in milliseconds (profile only) */
+    executionTime;
+    /** The operations feeding this one, in plan order */
+    children = [];
+    constructor(name, args, recordsProduced, executionTime) {
+        this.name = name;
+        this.args = args;
+        this.recordsProduced = recordsProduced;
+        this.executionTime = executionTime;
+    }
+    /** Parses one plan line, ignoring its indentation. */
+    static fromLine(line) {
+        let text = line.trim();
+        let recordsProduced;
+        let executionTime;
+        const last = text.lastIndexOf("|");
+        const stats = last === -1 ? null : PROFILE_STATS.exec(text.slice(last + 1));
+        if (stats) {
+            recordsProduced = parseInt(stats[1], 10);
+            executionTime = parseFloat(stats[2]);
+            text = text.slice(0, last).trimEnd();
+        }
+        // Names never contain a `|`, while arguments may (e.g. `(a:A|B)`)
+        const separator = text.indexOf("|");
+        const name = (separator === -1 ? text : text.slice(0, separator)).trim();
+        const args = separator === -1 ? undefined : text.slice(separator + 1).trim();
+        return new Operation(name, args || undefined, recordsProduced, executionTime);
+    }
+    /** The operation as it appears in an explain plan, e.g. `Filter` */
+    toString() {
+        return this.args === undefined ? this.name : `${this.name} | ${this.args}`;
+    }
+}
+exports.Operation = Operation;
+/** The operation tree of a query, as returned by `Graph.explain`/`Graph.profile`. */
+class ExecutionPlan {
+    /** The plan lines exactly as the server returned them */
+    steps;
+    /** The operation producing the query's result */
+    root;
+    constructor(steps) {
+        if (!Array.isArray(steps) || steps.length === 0) {
+            throw new TypeError("An execution plan must be a non-empty array of lines");
+        }
+        this.steps = steps;
+        // stack[level] is the latest operation seen at that depth, so the parent
+        // of an operation at depth `level` is always stack[level - 1]
+        const stack = [];
+        steps.forEach((line, index) => {
+            const spaces = line.length - line.trimStart().length;
+            const level = spaces / INDENT.length;
+            const valid = line.trim() !== "" &&
+                Number.isInteger(level) &&
+                (index === 0 ? level === 0 : level > 0 && level <= stack.length);
+            if (!valid) {
+                throw new Error(`Malformed execution plan at line ${index}: "${line}"`);
+            }
+            const operation = Operation.fromLine(line);
+            if (level > 0) {
+                stack[level - 1].children.push(operation);
+            }
+            stack.length = level;
+            stack.push(operation);
+        });
+        this.root = stack[0];
+    }
+    /** All operations named `name`, in plan order. */
+    collectOperations(name) {
+        return [...this].filter((operation) => operation.name === name);
+    }
+    /** Iterates over every operation, parents before their children. */
+    *[Symbol.iterator]() {
+        const pending = [this.root];
+        while (pending.length > 0) {
+            const operation = pending.pop();
+            yield operation;
+            for (let i = operation.children.length - 1; i >= 0; i--) {
+                pending.push(operation.children[i]);
+            }
+        }
+    }
+    /** The plan as indented lines, without profile statistics. */
+    toString() {
+        const lines = [];
+        const render = (operation, level) => {
+            lines.push(INDENT.repeat(level) + operation.toString());
+            operation.children.forEach((child) => render(child, level + 1));
+        };
+        render(this.root, 0);
+        return lines.join("\n");
+    }
+}
+exports.ExecutionPlan = ExecutionPlan;

package/dist/src/falkordb.js

@@ -44,7 +44,11 @@ async function clientFactory(client, sentinelOptions) {
         return new sentinel_1.Sentinel(client, sentinelOptions);
     }
     else if (info.includes("redis_mode:cluster")) {
-        return new cluster_1.Cluster(client);
+        // Connecting through a replica (or asking for `readonly`) opts in to
+        // serving read-only commands from replicas, see `Cluster`.
+        const replication = await client.info("replication");
+        const useReplicas = client.options?.readonly === true || /^role:slave\r?$/m.test(replication);
+        return new cluster_1.Cluster(client, { useReplicas });
     }
     return new single_1.Single(client);
 }
@@ -54,6 +58,7 @@ async function clientFactory(client, sentinelOptions) {
 const MAX_CACHED_GRAPHS = 1000;
 class FalkorDB extends events_1.EventEmitter {
     #client = new nullClient_1.NullClient();
+    #integers = 'number';
     #graphs = new Map();
     // Shared by every instance for a graph id, including ones evicted from
     // #graphs that callers still hold. Weakly held, so an entry lives only as
@@ -65,8 +70,11 @@ class FalkorDB extends events_1.EventEmitter {
         }
     });
     static async connect(options) {
-        const { host, port, retryWritesOnConnectionLoss, ...rest } = options ?? {};
+        const { host, port, retryWritesOnConnectionLoss, integers = 'number', ...rest } = options ?? {};
         const redisOption = rest;
+        if (integers !== 'number' && integers !== 'bigint') {
+            throw new TypeError(`integers must be 'number' or 'bigint', not ${JSON.stringify(integers)}`);
+        }
         // Support the top-level `host`/`port` shorthand used by the other FalkorDB
         // clients by folding them into the socket options node-redis expects.
         // Explicit `socket` values win, and `url` takes precedence over both.
@@ -131,11 +139,28 @@ class FalkorDB extends events_1.EventEmitter {
             falkordb.emit('error', err); })
             .connect();
         // Create FalkorDB client wrapper
-        const client = await clientFactory(redisClient, { retryWritesOnConnectionLoss });
-        await client.init(falkordb);
+        let client;
+        try {
+            client = await clientFactory(redisClient, { retryWritesOnConnectionLoss });
+            await client.init(falkordb);
+        }
+        catch (err) {
+            // The caller gets no instance to close, so close what is open here
+            try {
+                if (client)
+                    await client.disconnect();
+                else
+                    redisClient.destroy();
+            }
+            catch {
+                // Already closed
+            }
+            throw err;
+        }
         connected = true;
         // Set the client to the FalkorDB instance after it was initialized
         falkordb.#client = client;
+        falkordb.#integers = integers;
         return falkordb;
     }
     /**
@@ -163,6 +188,8 @@ class FalkorDB extends events_1.EventEmitter {
                         this.#graphs.delete(graphId);
                     }
                 },
+                selectGraph: (name) => this.selectGraph(name),
+                integers: this.#integers,
             });
         }
         this.#graphs.set(graphId, graph);