falkordb 6.9.2 → 6.9.3

package/README.md

@@ -10,6 +10,8 @@
 
 `falkordb` is a [FalkorDB](https://www.falkordb.com) client for Node.js.
 
+> **Upgrading from v6?** Version 7 has breaking changes; see the [migration guide](MIGRATION.md).
+
 ## Installation
 
 Start a falkordb via docker:
@@ -50,7 +52,9 @@ const 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(result.data)    // [{ 'r.name': 'Valentino Rossi' }]
+console.log(result.headers) // ['r.name']
+console.log(result.stats)   // { nodesCreated: 0, ..., cachedExecution: false, queryInternalExecutionTime: 0.31 }
 
 console.log(await db.list())
 console.log(await db.info())
@@ -60,6 +64,57 @@ db.close()
 
 To learn more about Cypher query language check: https://docs.falkordb.com/cypher/
 
+### Query Parameters
+
+Parameter values can be a `string`, a finite `number`, a `bigint`, a `boolean`, `null`, an array, a typed array
+(e.g. a `Float32Array` vector, sent as a list) or a plain object (sent as a map). Names that are not plain
+identifiers, such as `my-key` or `@type`, work too: quote them in the query, e.g. `` $`my-key` ``.
+An empty name, or one containing the `` ` `` character, throws a `TypeError`, since FalkorDB cannot
+represent it.
+
+```typescript
+await graph.query('RETURN $`my-key`, $vec', {params: {'my-key': 1, vec: new Float32Array([0.1, 0.2])}})
+```
+
+A plain object is an object literal or one made with `Object.create(null)`. Any other object, such as a
+class instance, `Date`, `Map` or `Set`, throws a `TypeError`, as do `undefined` and `NaN`; convert such
+values first:
+
+```typescript
+await graph.query('CREATE (:User $props)', {params: {props: {...user, createdAt: user.createdAt.toISOString()}}})
+```
+
+A `bigint` is sent exactly. Integers in query results are returned as a `number` by default, so values beyond
+`Number.MAX_SAFE_INTEGER` come back rounded; see [Large Integers](#large-integers) to read them exactly.
+
+### Large Integers
+
+To read every integer in query results exactly, connect with `integers: 'bigint'`. Integer values then come
+back as a `bigint`, including small ones; node and edge ids stay a `number`.
+
+```typescript
+const db = await FalkorDB.connect({ socket: { host: 'localhost', port: 6379 }, integers: 'bigint' })
+const { data } = await db.selectGraph('g').query('RETURN 9007199254740993 AS n')
+console.log(data) // [{ n: 9007199254740993n }]
+```
+
+`JSON.stringify` throws on a `bigint`, so convert such values before serializing them.
+
+### Query Replies
+
+`graph.query`, `graph.roQuery` and the index helpers (such as `graph.createNodeRangeIndex`) resolve to `{ headers?, data?, stats }`:
+`headers` and `data` are present when the query returns columns, and `stats` always holds the server's statistics as numbers (a counter the server did not report is `0`).
+
+```typescript
+const { stats } = await graph.query(`CREATE (:Rider {name:'Jorge Lorenzo'})`)
+
+console.log(stats.nodesCreated)               // 1
+console.log(stats.queryInternalExecutionTime) // milliseconds, e.g. 0.42
+console.log(stats.cachedExecution)            // false
+```
+
+Version 7 removed the raw `metadata` lines (such as `"Nodes created: 1"`) from these replies; read the matching `stats` field instead.
+
 ### Connection Options
 
 `host` and `port` are the shorthand for a plain TCP connection and default to `localhost:6379`.

package/dist/index.d.ts

@@ -2,4 +2,9 @@ export { Graph } from './src/graph';
 export { ConstraintType, EntityType } from './src/enums';
 export { FalkorDB } from './src/falkordb';
 export type { FalkorDBOptions } from './src/types';
-export type { QueryParam, QueryParams, QueryOptions, QueryOptionsBackwardCompatible } from './src/types';
+export type { GraphReply, QueryStatistics } from './src/types';
+export { ExecutionPlan, Operation } from './src/execution-plan';
+export { nodeToString, edgeToString, pathToString, nodesEqual, edgesEqual, pathsEqual } from './src/entities';
+export type { GraphNode, GraphEdge, GraphPath, GraphValue } from './src/types';
+export type { QueryParam, QueryParams, QueryOptions, QueryOptionsBackwardCompatible, PlanOptions } from './src/types';
+export type { CallProcedureOptions, ConstraintInfo, IndexInfo, VectorIndexOptions } from './src/types';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FalkorDB = exports.EntityType = exports.ConstraintType = exports.Graph = void 0;
+exports.pathsEqual = exports.edgesEqual = exports.nodesEqual = exports.pathToString = exports.edgeToString = exports.nodeToString = exports.Operation = exports.ExecutionPlan = exports.FalkorDB = exports.EntityType = exports.ConstraintType = exports.Graph = void 0;
 // Named re-exports, not `default as`: with esModuleInterop (always on since
 // TypeScript 6) a default re-export compiles to `__importDefault(m).default`,
 // which Node's CommonJS export detection cannot see, so ESM callers could not
@@ -12,3 +12,13 @@ Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: functi
 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.FalkorDB; } });
+var execution_plan_1 = require("./src/execution-plan");
+Object.defineProperty(exports, "ExecutionPlan", { enumerable: true, get: function () { return execution_plan_1.ExecutionPlan; } });
+Object.defineProperty(exports, "Operation", { enumerable: true, get: function () { return execution_plan_1.Operation; } });
+var entities_1 = require("./src/entities");
+Object.defineProperty(exports, "nodeToString", { enumerable: true, get: function () { return entities_1.nodeToString; } });
+Object.defineProperty(exports, "edgeToString", { enumerable: true, get: function () { return entities_1.edgeToString; } });
+Object.defineProperty(exports, "pathToString", { enumerable: true, get: function () { return entities_1.pathToString; } });
+Object.defineProperty(exports, "nodesEqual", { enumerable: true, get: function () { return entities_1.nodesEqual; } });
+Object.defineProperty(exports, "edgesEqual", { enumerable: true, get: function () { return entities_1.edgesEqual; } });
+Object.defineProperty(exports, "pathsEqual", { enumerable: true, get: function () { return entities_1.pathsEqual; } });

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

@@ -1,7 +1,14 @@
 import { RedisArgument } from "@redis/client";
 import { ConstraintType, EntityType } from "../enums";
 import FalkorDB from "../falkordb";
-import type { MemoryUsageOptions, MemoryUsageReply, QueryOptions, SingleGraphConnection, SlowLogReply, UdfListReply } from "../types";
+import type { MemoryUsageOptions, MemoryUsageReply, PlanOptions, QueryOptions, SingleGraphConnection, SlowLogReply, UdfListReply } from "../types";
+/**
+ * Returns integer replies as their exact digits, for graphs whose integers
+ * are read as `bigint`: a `number` would round any beyond 2^53.
+ */
+export declare const EXACT_INTEGERS: {
+    readonly 58: StringConstructor;
+};
 export interface Client {
     init(falkordb: FalkorDB): Promise<void>;
     list(): Promise<Array<string>>;
@@ -16,14 +23,25 @@ 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, version?: number): Promise<any>;
-    profile<T>(graph: string, query: RedisArgument): Promise<any>;
-    roQuery<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number): Promise<any>;
+    /**
+     * @param exactIntegers Return integer replies as strings of their exact
+     * digits (see `EXACT_INTEGERS`)
+     */
+    query<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number, exactIntegers?: boolean): Promise<any>;
+    profile<T>(graph: string, query: RedisArgument, options?: PlanOptions): Promise<any>;
+    /**
+     * @param primary Run on the graph's master even where reads may be served
+     * by replicas, for a reply that must be at least as new as the master's
+     * @param exactIntegers Return integer replies as strings of their exact
+     * digits (see `EXACT_INTEGERS`)
+     */
+    roQuery<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number, primary?: boolean, exactIntegers?: boolean): Promise<any>;
     copy<T>(srcGraph: string, destGraph: string): Promise<any>;
     delete(graph: string): Promise<void>;
-    explain(graph: string, query: string): Promise<any>;
+    explain(graph: string, query: string, options?: PlanOptions): Promise<any>;
     memoryUsage(graph: string, options?: MemoryUsageOptions): Promise<MemoryUsageReply>;
     slowLog(graph: string): Promise<SlowLogReply>;
+    slowLogReset(graph: string): Promise<void>;
     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/client.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXACT_INTEGERS = void 0;
+const client_1 = require("@redis/client");
+/**
+ * Returns integer replies as their exact digits, for graphs whose integers
+ * are read as `bigint`: a `number` would round any beyond 2^53.
+ */
+exports.EXACT_INTEGERS = { [client_1.RESP_TYPES.NUMBER]: String };

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

@@ -3,19 +3,28 @@ import { ConstraintType, EntityType } from "../enums";
 import { RedisArgument, RedisFunctions, RedisScripts } from "@redis/client";
 import commands from "../commands";
 import FalkorDB from "../falkordb";
-import type { ClusterGraphConnection, MemoryUsageOptions, MemoryUsageReply, QueryOptions, SingleGraphConnection, UdfListReply } from "../types";
+import type { ClusterGraphConnection, MemoryUsageOptions, MemoryUsageReply, PlanOptions, QueryOptions, SingleGraphConnection, UdfListReply } from "../types";
 export type { ClusterGraphConnection };
+export interface ClusterOptions {
+    /**
+     * Serve read-only commands (e.g. `GRAPH.RO_QUERY`) from replicas as well as
+     * masters. Replica connections are sent
+     * [`READONLY`](https://redis.io/docs/latest/commands/readonly/) so they
+     * answer reads instead of redirecting them; writes still go to the masters.
+     */
+    useReplicas?: boolean;
+}
 /**
  * A client that connects to a Redis Cluster.
  */
 export declare class Cluster implements Client {
     #private;
-    constructor(client: SingleGraphConnection);
+    constructor(client: SingleGraphConnection, { useReplicas }?: ClusterOptions);
     getConnection(): Promise<import("@redis/client").RedisClientType<{
         falkordb: typeof commands;
     }, RedisFunctions, RedisScripts, 2, {}>>;
     init(falkordb: FalkorDB): Promise<void>;
-    query<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number): Promise<{
+    query<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number, exactIntegers?: boolean): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -24,7 +33,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, version?: number): Promise<{
+    roQuery<T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number, primary?: boolean, exactIntegers?: boolean): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -34,7 +43,7 @@ export declare class Cluster implements Client {
         metadata: string[];
     }>;
     delete(graph: string): Promise<void>;
-    explain(graph: string, query: string): Promise<string[]>;
+    explain(graph: string, query: string, options?: PlanOptions): Promise<string[]>;
     list(): Promise<Array<string>>;
     stubs(): Promise<Array<string>>;
     configGet(configKey: string): Promise<(string | number)[][] | (string | number)[]>;
@@ -47,6 +56,7 @@ export declare class Cluster implements Client {
         query: string;
         took: number;
     }[]>;
+    slowLogReset(graph: string): Promise<void>;
     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>;
@@ -54,7 +64,7 @@ export declare class Cluster implements Client {
     udfList(lib?: string, withCode?: boolean): Promise<UdfListReply>;
     udfFlush(): Promise<string>;
     udfDelete(lib: string): Promise<string>;
-    profile<_T>(graph: string, query: string): Promise<string[]>;
+    profile<_T>(graph: string, query: string, options?: PlanOptions): Promise<string[]>;
     quit(): Promise<void>;
     disconnect(): Promise<void>;
 }

package/dist/src/clients/cluster.js

@@ -34,14 +34,16 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cluster = void 0;
-const client_1 = require("@redis/client");
+const client_1 = require("./client");
+const RO_QUERY = __importStar(require("../commands/RO_QUERY"));
+const client_2 = require("@redis/client");
 const lodash = __importStar(require("lodash"));
 /**
  * A client that connects to a Redis Cluster.
  */
 class Cluster {
     #client;
-    constructor(client) {
+    constructor(client, { useReplicas = false } = {}) {
         // Convert the single client options to a cluster client options
         const redisClusterOption = client.options;
         redisClusterOption.rootNodes = [
@@ -52,11 +54,19 @@ class Cluster {
         defaults?.url && delete defaults.url;
         redisClusterOption.defaults = defaults;
         redisClusterOption.maxCommandRedirections = 100000;
+        redisClusterOption.useReplicas = useReplicas;
         client.disconnect();
-        this.#client = (0, client_1.createCluster)(redisClusterOption);
+        this.#client = (0, client_2.createCluster)(redisClusterOption);
     }
     async getConnection() {
-        const connection = this.#client.nodeClient(this.#client.getRandomNode());
+        return this.#masterClient();
+    }
+    // Keyless commands are routed to a random node, which can be a replica when
+    // `useReplicas` is on, so writes without a key are sent to a master instead.
+    async #masterClient() {
+        const { masters } = this.#client;
+        const master = masters[Math.floor(Math.random() * masters.length)];
+        const connection = this.#client.nodeClient(master);
         return connection instanceof Promise ? await connection : connection;
     }
     async init(falkordb) {
@@ -65,19 +75,30 @@ class Cluster {
             .connect();
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async query(graph, query, options, compact = true, version) {
-        return this.#client.falkordb.query(graph, query, options, compact, version);
+    async query(graph, query, options, compact = true, version, exactIntegers = false) {
+        return this.#withIntegers(exactIntegers).falkordb.query(graph, query, options, compact, version);
+    }
+    #withIntegers(exactIntegers) {
+        return exactIntegers ? this.#client.withTypeMapping(client_1.EXACT_INTEGERS) : this.#client;
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async roQuery(graph, query, options, compact = true, version) {
-        return this.#client.falkordb.roQuery(graph, query, options, compact, version);
+    async roQuery(graph, query, options, compact = true, version, primary = false, exactIntegers = false) {
+        if (primary) {
+            // Still GRAPH.RO_QUERY, so read-only users can run it, but routed to the
+            // slot's master as a write would be
+            const args = RO_QUERY.transformArguments(graph, query, options, compact, version);
+            return RO_QUERY.transformReply(exactIntegers
+                ? await this.#client.sendCommand(graph, false, args, { typeMapping: client_1.EXACT_INTEGERS })
+                : await this.#client.sendCommand(graph, false, args));
+        }
+        return this.#withIntegers(exactIntegers).falkordb.roQuery(graph, query, options, compact, version);
     }
     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 explain(graph, query, options) {
+        return this.#client.falkordb.explain(graph, query, options);
     }
     async list() {
         const reply = await Promise.all(this.#client.masters.map(async (master) => {
@@ -120,7 +141,7 @@ class Cluster {
         return this.#client.falkordb.configGet(configKey);
     }
     async configSet(configKey, value) {
-        const reply = this.#client.falkordb.configSet(configKey, value);
+        const reply = (await this.#masterClient()).falkordb.configSet(configKey, value);
         return reply.then(() => { });
     }
     async info(section) {
@@ -132,6 +153,10 @@ class Cluster {
     slowLog(graph) {
         return this.#client.falkordb.slowLog(graph);
     }
+    async slowLogReset(graph) {
+        const reply = this.#client.falkordb.slowLogReset(graph);
+        return reply.then(() => { });
+    }
     async memoryUsage(graph, options) {
         return this.#client.falkordb.memoryUsage(graph, options);
     }
@@ -144,19 +169,19 @@ class Cluster {
         return reply.then(() => { });
     }
     async udfLoad(name, script, replace = false) {
-        return this.#client.falkordb.udfLoad(name, script, replace);
+        return (await this.#masterClient()).falkordb.udfLoad(name, script, replace);
     }
     async udfList(lib, withCode = false) {
         return this.#client.falkordb.udfList(lib, withCode);
     }
     async udfFlush() {
-        return this.#client.falkordb.udfFlush();
+        return (await this.#masterClient()).falkordb.udfFlush();
     }
     async udfDelete(lib) {
-        return this.#client.falkordb.udfDelete(lib);
+        return (await this.#masterClient()).falkordb.udfDelete(lib);
     }
-    async profile(graph, query) {
-        return this.#client.falkordb.profile(graph, query);
+    async profile(graph, query, options) {
+        return this.#client.falkordb.profile(graph, query, options);
     }
     async quit() {
         return this.disconnect();

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

@@ -2,7 +2,7 @@ import { RedisArgument } from "@redis/client";
 import FalkorDB from "../falkordb";
 import { ConstraintType, EntityType } from "../enums";
 import { Client } from "./client";
-import type { MemoryUsageOptions, MemoryUsageReply, QueryOptions, SingleGraphConnection, SlowLogReply, UdfListReply } from "../types";
+import type { MemoryUsageOptions, MemoryUsageReply, PlanOptions, QueryOptions, SingleGraphConnection, SlowLogReply, UdfListReply } from "../types";
 /**
  * The `NullClient` class is a placeholder implementation of the `Client` interface.
  *
@@ -23,12 +23,13 @@ export declare class NullClient implements Client {
     configSet(_configKey: string, _value: number | string): Promise<void>;
     info(_section?: string): Promise<(string | string[])[]>;
     query<_T>(_graph: string, _query: RedisArgument, _options?: QueryOptions): Promise<any>;
-    profile<_T>(_graph: string, _query: RedisArgument): Promise<any>;
+    profile<_T>(_graph: string, _query: RedisArgument, _options?: PlanOptions): Promise<any>;
     roQuery<_T>(_graph: string, _query: RedisArgument, _options?: QueryOptions): Promise<any>;
     copy<_T>(_srcGraph: string, _destGraph: string): Promise<any>;
     delete(_graph: string): Promise<void>;
-    explain(_graph: string, _query: string): Promise<any>;
+    explain(_graph: string, _query: string, _options?: PlanOptions): Promise<any>;
     slowLog(_graph: string): Promise<SlowLogReply>;
+    slowLogReset(_graph: string): Promise<void>;
     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/nullClient.js

@@ -37,7 +37,7 @@ class NullClient {
     query(_graph, _query, _options) {
         throw new Error("Method not implemented.");
     }
-    profile(_graph, _query) {
+    profile(_graph, _query, _options) {
         throw new Error("Method not implemented.");
     }
     roQuery(_graph, _query, _options) {
@@ -49,12 +49,15 @@ class NullClient {
     delete(_graph) {
         throw new Error("Method not implemented.");
     }
-    explain(_graph, _query) {
+    explain(_graph, _query, _options) {
         throw new Error("Method not implemented.");
     }
     slowLog(_graph) {
         throw new Error("Method not implemented.");
     }
+    slowLogReset(_graph) {
+        throw new Error("Method not implemented.");
+    }
     memoryUsage(_graph, _options) {
         throw new Error("Method not implemented.");
     }

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

@@ -2,7 +2,7 @@ import { Client } from "./client";
 import { ConstraintType, EntityType } from "../enums";
 import { RedisArgument } from "@redis/client";
 import FalkorDB from "../falkordb";
-import type { MemoryUsageOptions, MemoryUsageReply, QueryOptions, SingleGraphConnection, UdfListReply } from "../types";
+import type { MemoryUsageOptions, MemoryUsageReply, PlanOptions, QueryOptions, SingleGraphConnection, UdfListReply } from "../types";
 export type { SingleGraphConnection };
 export interface RunOptions {
     /** The command does not change data, so running it twice is harmless */
@@ -17,7 +17,7 @@ export declare class Single implements Client {
      * 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<{
+    query<_T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number, exactIntegers?: boolean): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -26,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, version?: number): Promise<{
+    roQuery<_T>(graph: string, query: RedisArgument, options?: QueryOptions, compact?: boolean, version?: number, _primary?: boolean, exactIntegers?: boolean): Promise<{
         headers: undefined;
         data: undefined;
         metadata: string[];
@@ -36,8 +36,8 @@ export declare class Single implements Client {
         metadata: string[];
     }>;
     delete(graph: string): Promise<void>;
-    explain(graph: string, query: string): Promise<string[]>;
-    profile<_T>(graph: string, query: string): Promise<string[]>;
+    explain(graph: string, query: string, options?: PlanOptions): Promise<string[]>;
+    profile<_T>(graph: string, query: string, options?: PlanOptions): Promise<string[]>;
     list(): Promise<string[]>;
     stubs(): Promise<string[]>;
     configGet(configKey: string): Promise<(string | number)[][] | (string | number)[]>;
@@ -49,6 +49,7 @@ export declare class Single implements Client {
         query: string;
         took: number;
     }[]>;
+    slowLogReset(graph: string): Promise<void>;
     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/single.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Single = void 0;
+const client_1 = require("./client");
 const READ_ONLY = { readOnly: true };
+function withIntegers(client, exactIntegers) {
+    return exactIntegers ? client.withTypeMapping(client_1.EXACT_INTEGERS) : client;
+}
 class Single {
     client;
     constructor(client) {
@@ -17,21 +21,22 @@ class Single {
     run(fn, _options = {}) {
         return fn(this.client);
     }
-    async query(graph, query, options, compact = true, version) {
-        return await this.run((client) => client.falkordb.query(graph, query, options, compact, version));
+    async query(graph, query, options, compact = true, version, exactIntegers = false) {
+        return await this.run((client) => withIntegers(client, exactIntegers).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);
+    // A single node serves every read, so `primary` needs no handling
+    async roQuery(graph, query, options, compact = true, version, _primary = false, exactIntegers = false) {
+        return await this.run((client) => withIntegers(client, exactIntegers).falkordb.roQuery(graph, query, options, compact, version), READ_ONLY);
     }
     async delete(graph) {
         const reply = this.run((client) => client.falkordb.delete(graph));
         return reply.then(() => { });
     }
-    async explain(graph, query) {
-        return this.run((client) => client.falkordb.explain(graph, query), READ_ONLY);
+    async explain(graph, query, options) {
+        return this.run((client) => client.falkordb.explain(graph, query, options), READ_ONLY);
     }
-    async profile(graph, query) {
-        return this.run((client) => client.falkordb.profile(graph, query));
+    async profile(graph, query, options) {
+        return this.run((client) => client.falkordb.profile(graph, query, options));
     }
     async list() {
         return this.run((client) => client.falkordb.list(), READ_ONLY);
@@ -52,6 +57,10 @@ class Single {
     async slowLog(graph) {
         return this.run((client) => client.falkordb.slowLog(graph), READ_ONLY);
     }
+    async slowLogReset(graph) {
+        const reply = this.run((client) => client.falkordb.slowLogReset(graph));
+        return reply.then(() => { });
+    }
     async memoryUsage(graph, options) {
         return this.run((client) => client.falkordb.memoryUsage(graph, options), READ_ONLY);
     }

package/dist/src/commands/CONSTRAINT_CREATE.js

@@ -9,7 +9,9 @@ Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: functi
 Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return enums_1.EntityType; } });
 // GRAPH.CONSTRAINT CREATE key constraintType {NODE label | RELATIONSHIP reltype} PROPERTIES propCount prop [prop...]
 function parseCommand(parser, key, constraintType, entityType, label, ...properties) {
-    parser.push('GRAPH.CONSTRAINT', 'CREATE', key, constraintType, entityType, label, 'PROPERTIES', properties.length.toString(), ...properties);
+    parser.push('GRAPH.CONSTRAINT', 'CREATE');
+    parser.pushKey(key);
+    parser.push(constraintType, entityType, label, 'PROPERTIES', properties.length.toString(), ...properties);
 }
 function transformArguments(key, constraintType, entityType, label, ...properties) {
     return [

package/dist/src/commands/CONSTRAINT_DROP.js

@@ -5,7 +5,9 @@ exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
 // GRAPH.CONSTRAINT DROP key constraintType {NODE label | RELATIONSHIP reltype} PROPERTIES propCount prop [prop...]
 function parseCommand(parser, key, constraintType, entityType, label, ...properties) {
-    parser.push('GRAPH.CONSTRAINT', 'DROP', key, constraintType, entityType, label, 'PROPERTIES', properties.length.toString(), ...properties);
+    parser.push('GRAPH.CONSTRAINT', 'DROP');
+    parser.pushKey(key);
+    parser.push(constraintType, entityType, label, 'PROPERTIES', properties.length.toString(), ...properties);
 }
 function transformArguments(key, constraintType, entityType, label, ...properties) {
     return [

package/dist/src/commands/COPY.js

@@ -4,7 +4,9 @@ exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
 function parseCommand(parser, srcGraph, destGraph) {
-    parser.push('GRAPH.COPY', srcGraph, destGraph);
+    parser.push('GRAPH.COPY');
+    parser.pushKey(srcGraph);
+    parser.pushKey(destGraph);
 }
 function transformArguments(srcGraph, destGraph) {
     return [

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

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

package/dist/src/commands/EXPLAIN.js

@@ -4,15 +4,16 @@ exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
 exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
+const _1 = require(".");
 exports.FIRST_KEY_INDEX = 1;
 exports.IS_READ_ONLY = true;
-function parseCommand(parser, key, query) {
+function parseCommand(parser, key, query, options) {
     parser.push('GRAPH.EXPLAIN');
     parser.pushKey(key);
-    parser.push(query);
+    parser.push((0, _1.withParamsHeader)(query, options?.params));
 }
-function transformArguments(key, query) {
-    return ['GRAPH.EXPLAIN', key, query];
+function transformArguments(key, query, options) {
+    return ['GRAPH.EXPLAIN', key, (0, _1.withParamsHeader)(query, options?.params)];
 }
 function transformReply(reply) {
     return reply;

package/dist/src/commands/MEMORY_USAGE.js

@@ -4,14 +4,17 @@ exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
 function parseCommand(parser, key, options) {
-    parser.push("GRAPH.MEMORY", "USAGE", key);
-    if (options?.SAMPLES) {
-        parser.push(String(options.SAMPLES));
+    parser.push("GRAPH.MEMORY", "USAGE");
+    parser.pushKey(key);
+    if (options?.SAMPLES !== undefined) {
+        parser.push("SAMPLES", String(options.SAMPLES));
     }
 }
 function transformArguments(key, options) {
     const args = ["GRAPH.MEMORY", "USAGE", key];
-    return options?.SAMPLES ? [...args, String(options.SAMPLES)] : [...args];
+    return options?.SAMPLES !== undefined
+        ? [...args, "SAMPLES", String(options.SAMPLES)]
+        : args;
 }
 function transformReply(reply) {
     return reply;

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

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

package/dist/src/commands/PROFILE.js

@@ -4,15 +4,17 @@ exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
 exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
+const _1 = require(".");
 exports.FIRST_KEY_INDEX = 1;
-exports.IS_READ_ONLY = true;
-function parseCommand(parser, key, query) {
+// PROFILE executes the query, which may write
+exports.IS_READ_ONLY = false;
+function parseCommand(parser, key, query, options) {
     parser.push('GRAPH.PROFILE');
     parser.pushKey(key);
-    parser.push(query);
+    parser.push((0, _1.withParamsHeader)(query, options?.params));
 }
-function transformArguments(key, query) {
-    return ['GRAPH.PROFILE', key, query];
+function transformArguments(key, query, options) {
+    return ['GRAPH.PROFILE', key, (0, _1.withParamsHeader)(query, options?.params)];
 }
 function transformReply(reply) {
     return reply;