falkordb 6.8.0 → 6.9.0

package/dist/src/falkordb.js

@@ -1,27 +1,70 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = require("events");
 const redis_1 = require("redis");
-const graph_1 = require("./graph");
-const commands_1 = require("./commands");
+const graph_1 = __importDefault(require("./graph"));
+const commands_1 = __importDefault(require("./commands"));
+const client_1 = require("@redis/client");
 const single_1 = require("./clients/single");
 const sentinel_1 = require("./clients/sentinel");
 const cluster_1 = require("./clients/cluster");
 const nullClient_1 = require("./clients/nullClient");
-async function clientFactory(client) {
+/**
+ * Retries the initial connection gets before `FalkorDB.connect()` rejects.
+ */
+const INITIAL_CONNECT_RETRIES = 3;
+/**
+ * node-redis' default back-off: exponential up to 2s plus jitter, and no
+ * reconnect after a socket timeout.
+ */
+function defaultReconnectStrategy(retries, cause) {
+    if (cause instanceof client_1.SocketTimeoutError) {
+        return false;
+    }
+    return Math.min(Math.pow(2, retries) * 50, 2000) + Math.floor(Math.random() * 200);
+}
+function initialReconnectStrategy(retries, cause, tlsEnabled) {
+    if (retries < INITIAL_CONNECT_RETRIES) {
+        return defaultReconnectStrategy(retries, cause);
+    }
+    // A TLS server drops a plain-text client mid-handshake, which node-redis
+    // reports as the socket closing unexpectedly.
+    const hint = !tlsEnabled && cause instanceof client_1.SocketClosedUnexpectedlyError
+        ? ' The server closed the connection during the handshake; if it requires TLS, set `socket.tls: true` or use a `rediss://` URL.'
+        : '';
+    return new Error(`Failed to connect to FalkorDB: ${cause.message}.${hint}`, { cause });
+}
+async function clientFactory(client, sentinelOptions) {
     const info = await client.info("server");
     if (info.includes("redis_mode:sentinel")) {
-        return new sentinel_1.Sentinel(client);
+        return new sentinel_1.Sentinel(client, sentinelOptions);
     }
     else if (info.includes("redis_mode:cluster")) {
         return new cluster_1.Cluster(client);
     }
     return new single_1.Single(client);
 }
+// Upper bound on the `Graph` instances `selectGraph` keeps. Past it the least
+// recently selected one is dropped; that only costs its metadata cache, which
+// the next `selectGraph` for that id rebuilds.
+const MAX_CACHED_GRAPHS = 1000;
 class FalkorDB extends events_1.EventEmitter {
     #client = new nullClient_1.NullClient();
+    #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
+    // long as some instance using it does.
+    #schemas = new Map();
+    #schemasCleanup = new FinalizationRegistry((graphId) => {
+        if (!this.#schemas.get(graphId)?.deref()) {
+            this.#schemas.delete(graphId);
+        }
+    });
     static async connect(options) {
-        const { host, port, ...rest } = options ?? {};
+        const { host, port, retryWritesOnConnectionLoss, ...rest } = options ?? {};
         const redisOption = rest;
         // Support the top-level `host`/`port` shorthand used by the other FalkorDB
         // clients by folding them into the socket options node-redis expects.
@@ -41,22 +84,100 @@ class FalkorDB extends events_1.EventEmitter {
         redisOption.modules = {
             falkordb: commands_1.default
         };
+        // node-redis v6 defaults to RESP3, which auto-converts module map replies
+        // into nested objects: `GRAPH.MEMORY USAGE` comes back as
+        // `{ total_graph_sz_mb: 0, ... }` instead of the flat
+        // `['total_graph_sz_mb', 0, ...]` that the reply parsers - and the
+        // `MemoryUsageReply` array type - are written against. So RESP 2 is a
+        // requirement here, not a default: honouring an explicit RESP 3 would
+        // hand the caller a reply shape the published types say is impossible.
+        // The sentinel and cluster clients reuse this options object, so they
+        // inherit the pin too.
+        const requestedRESP = redisOption.RESP;
+        if (requestedRESP !== undefined && requestedRESP !== 2) {
+            throw new Error(`FalkorDB requires RESP 2, but RESP ${requestedRESP} was requested. ` +
+                'Under RESP 3 node-redis rewrites module map replies into objects, which does ' +
+                'not match the reply shapes this client parses and publishes types for.');
+        }
+        redisOption.RESP = 2;
+        // node-redis retries the first connection forever by default, so a server
+        // that keeps closing the socket - e.g. a TLS server reached without TLS -
+        // leaves `connect()` pending indefinitely. Unless the caller chose a
+        // strategy, give up after a few attempts while connecting and keep the
+        // usual unbounded back-off once connected. The sentinel and cluster
+        // clients reuse these socket options, so `connected` is only set once
+        // they are up too: a node discovered during `init()` that cannot be
+        // reached must fail `connect()` as well.
+        let connected = false;
+        if (redisOption.socket?.reconnectStrategy === undefined) {
+            const tlsEnabled = redisOption.socket?.tls === true || !!redisOption.url?.startsWith('rediss:');
+            redisOption.socket = {
+                ...redisOption.socket,
+                reconnectStrategy: (retries, cause) => connected
+                    ? defaultReconnectStrategy(retries, cause)
+                    : initialReconnectStrategy(retries, cause, tlsEnabled),
+            };
+        }
         // Create an empty FalkorDB instance for the redisClient on error event to work
         const falkordb = new FalkorDB();
         // Create initial redis single client
         const redisClient = (0, redis_1.createClient)(redisOption);
         await redisClient
-            .on('error', err => falkordb.emit('error', err)) // Forward errors
+            // Forward errors. Nobody can listen on `falkordb` before it is returned,
+            // so emitting while connecting would only throw an unhandled 'error';
+            // those failures reach the caller as the rejection of `connect()`.
+            .on('error', err => { if (connected)
+            falkordb.emit('error', err); })
             .connect();
         // Create FalkorDB client wrapper
-        const client = await clientFactory(redisClient);
+        const client = await clientFactory(redisClient, { retryWritesOnConnectionLoss });
         await client.init(falkordb);
+        connected = true;
         // Set the client to the FalkorDB instance after it was initialized
         falkordb.#client = client;
         return falkordb;
     }
+    /**
+     * Returns the `Graph` for `graphId`. Repeated calls with the same id return
+     * the same instance, so its cached metadata (labels, relationship types and
+     * property keys) is shared instead of being refetched by every new handle.
+     * The instance is released when the graph is deleted through it, or when
+     * more than `MAX_CACHED_GRAPHS` graphs have been selected since its last use.
+     * Each query carries the schema version the cached metadata matches, so a
+     * schema changed by another client (e.g. the graph deleted and recreated) is
+     * rejected by the server and the metadata refreshed before the query is retried.
+     */
     selectGraph(graphId) {
-        return new graph_1.default(this.#client, graphId);
+        let graph = this.#graphs.get(graphId);
+        if (graph) {
+            // Re-insert so the Map's insertion order tracks recency of use
+            this.#graphs.delete(graphId);
+        }
+        else {
+            graph = new graph_1.default(this.#client, graphId, {
+                schema: this.#schema(graphId),
+                onDelete: (deleted) => {
+                    // An instance already evicted must not remove its replacement
+                    if (this.#graphs.get(graphId) === deleted) {
+                        this.#graphs.delete(graphId);
+                    }
+                },
+            });
+        }
+        this.#graphs.set(graphId, graph);
+        if (this.#graphs.size > MAX_CACHED_GRAPHS) {
+            this.#graphs.delete(this.#graphs.keys().next().value);
+        }
+        return graph;
+    }
+    #schema(graphId) {
+        let schema = this.#schemas.get(graphId)?.deref();
+        if (!schema) {
+            schema = { generation: 0, version: 0 };
+            this.#schemas.set(graphId, new WeakRef(schema));
+            this.#schemasCleanup.register(schema, graphId);
+        }
+        return schema;
     }
     get connection() {
         return this.#client.getConnection();
@@ -100,6 +221,8 @@ class FalkorDB extends events_1.EventEmitter {
      * Closes the client.
      */
     async close() {
+        this.#graphs.clear();
+        this.#schemas.clear();
         return this.#client.disconnect();
     }
 }

package/dist/src/graph.d.ts

@@ -1,28 +1,40 @@
 import { RedisArgument } from "@redis/client";
-import { QueryOptions } from "./commands";
-import { QueryReply } from "./commands/QUERY";
-import { ConstraintType, EntityType } from "./commands/CONSTRAINT_CREATE";
 import { Client } from "./clients/client";
-import { MemoryUsageOptions } from "./commands/MEMORY_USAGE";
+import { ConstraintType, EntityType } from "./enums";
+import type { GraphReply, MemoryUsageOptions, QueryOptions, QueryReply } from "./types";
 export { ConstraintType, EntityType };
-export type GraphReply<T> = Omit<QueryReply, "headers" | "data"> & {
-    data?: Array<T>;
-};
+export type { GraphReply };
+/**
+ * What the client knows about a graph's schema. Every `Graph` instance for the
+ * same graph shares one, so a change seen through any of them invalidates the
+ * metadata cached by all of them.
+ */
+export interface GraphSchemaState {
+    generation: number;
+    version: number;
+}
+export interface GraphCacheOptions {
+    schema?: GraphSchemaState;
+    onDelete?: (graph: Graph) => void;
+}
 export default class Graph {
     #private;
-    constructor(client: Client, name: string);
+    constructor(client: Client, name: string, cache?: GraphCacheOptions);
     query<T>(query: RedisArgument, options?: QueryOptions): Promise<GraphReply<T>>;
     roQuery<T>(query: RedisArgument, options?: QueryOptions): Promise<GraphReply<T>>;
     delete(): Promise<void>;
+    /**
+     * Drops the cached labels, relationship types and property keys, here and in
+     * every other instance `selectGraph` returned for this graph, so they are
+     * refetched the next time a reply needs them. A fetch already in flight does
+     * not repopulate the cache. Schema changes made by other clients are detected
+     * on the next query, so this is rarely needed.
+     */
+    clearMetadataCache(): void;
     explain(query: string): Promise<any>;
     profile(query: string): Promise<any>;
-    memoryUsage(options?: MemoryUsageOptions): Promise<import("./commands/MEMORY_USAGE").MemoryUsageReply>;
-    slowLog(): Promise<{
-        timestamp: Date;
-        command: string;
-        query: string;
-        took: number;
-    }[]>;
+    memoryUsage(options?: MemoryUsageOptions): Promise<import("./types").MemoryUsageReply>;
+    slowLog(): Promise<import("./types").SlowLogReply>;
     constraintCreate(constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
     constraintDrop(constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Promise<void>;
     copy(destGraph: string): Promise<any>;

package/dist/src/graph.js

@@ -1,50 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityType = exports.ConstraintType = void 0;
-const CONSTRAINT_CREATE_1 = require("./commands/CONSTRAINT_CREATE");
-Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return CONSTRAINT_CREATE_1.ConstraintType; } });
-Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return CONSTRAINT_CREATE_1.EntityType; } });
 const polyfill_1 = require("@js-temporal/polyfill");
-// https://github.com/FalkorDB/FalkorDB/blob/master/src/resultset/formatters/resultset_formatter.h#L20
-var GraphValueTypes;
-(function (GraphValueTypes) {
-    GraphValueTypes[GraphValueTypes["UNKNOWN"] = 0] = "UNKNOWN";
-    GraphValueTypes[GraphValueTypes["NULL"] = 1] = "NULL";
-    GraphValueTypes[GraphValueTypes["STRING"] = 2] = "STRING";
-    GraphValueTypes[GraphValueTypes["INTEGER"] = 3] = "INTEGER";
-    GraphValueTypes[GraphValueTypes["BOOLEAN"] = 4] = "BOOLEAN";
-    GraphValueTypes[GraphValueTypes["DOUBLE"] = 5] = "DOUBLE";
-    GraphValueTypes[GraphValueTypes["ARRAY"] = 6] = "ARRAY";
-    GraphValueTypes[GraphValueTypes["EDGE"] = 7] = "EDGE";
-    GraphValueTypes[GraphValueTypes["NODE"] = 8] = "NODE";
-    GraphValueTypes[GraphValueTypes["PATH"] = 9] = "PATH";
-    GraphValueTypes[GraphValueTypes["MAP"] = 10] = "MAP";
-    GraphValueTypes[GraphValueTypes["POINT"] = 11] = "POINT";
-    GraphValueTypes[GraphValueTypes["VECTORF32"] = 12] = "VECTORF32";
-    GraphValueTypes[GraphValueTypes["DATETIME"] = 13] = "DATETIME";
-    GraphValueTypes[GraphValueTypes["DATE"] = 14] = "DATE";
-    GraphValueTypes[GraphValueTypes["TIME"] = 15] = "TIME";
-    GraphValueTypes[GraphValueTypes["DURATION"] = 16] = "DURATION";
-})(GraphValueTypes || (GraphValueTypes = {}));
-// export type GraphConnection = SingleGraphConnection | ClusterGraphConnection;
+const enums_1 = require("./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; } });
+const errors_1 = require("./errors");
 class Graph {
     #client;
     #name;
     #metadata;
-    constructor(client, name) {
+    #schema;
+    #onDelete;
+    constructor(client, name, cache) {
         this.#client = client;
         this.#name = name;
+        this.#schema = cache?.schema ?? { generation: 0, version: 0 };
+        this.#onDelete = cache?.onDelete;
     }
     async query(query, options) {
-        const reply = await this.#client.query(this.#name, query, options);
+        const reply = await this.#withSchemaVersion((version) => this.#client.query(this.#name, query, options, true, version));
         return this.#parseReply(reply);
     }
     async roQuery(query, options) {
-        const reply = await this.#client.roQuery(this.#name, query, options);
+        const reply = await this.#withSchemaVersion((version) => this.#client.roQuery(this.#name, query, options, true, version));
         return this.#parseReply(reply);
     }
+    async #withSchemaVersion(run) {
+        try {
+            return await run(this.#schema.version);
+        }
+        catch (err) {
+            if (!(err instanceof errors_1.SchemaVersionMismatchError))
+                throw err;
+            // The server rejected the query without running it, so retrying is
+            // safe. Metadata fetched from here on is at least as new as
+            // `err.version`, so pairing the two is sound. The retry is sent without
+            // a version so that further concurrent schema changes cannot make it
+            // loop; names they add get new ids and are fetched when needed.
+            this.clearMetadataCache();
+            this.#schema.version = err.version;
+            return run();
+        }
+    }
     async delete() {
-        return this.#client.delete(this.#name);
+        const reply = await this.#client.delete(this.#name);
+        // The instance is reused by `selectGraph`, and a graph recreated under the
+        // same name assigns new ids, so the cached metadata must not outlive it.
+        this.clearMetadataCache();
+        // A recreated graph starts from an empty schema, whose version is 0
+        this.#schema.version = 0;
+        this.#onDelete?.(this);
+        return reply;
+    }
+    /**
+     * Drops the cached labels, relationship types and property keys, here and in
+     * every other instance `selectGraph` returned for this graph, so they are
+     * refetched the next time a reply needs them. A fetch already in flight does
+     * not repopulate the cache. Schema changes made by other clients are detected
+     * on the next query, so this is rarely needed.
+     */
+    clearMetadataCache() {
+        this.#schema.generation++;
+        this.#metadata = undefined;
     }
     async explain(query) {
         return this.#client.explain(this.#name, query);
@@ -67,30 +85,50 @@ class Graph {
     async copy(destGraph) {
         return this.#client.copy(this.#name, destGraph);
     }
-    #setMetadataPromise;
+    #pendingMetadata;
     #updateMetadata() {
-        this.#setMetadataPromise ??= this.#setMetadata().finally(() => (this.#setMetadataPromise = undefined));
-        return this.#setMetadataPromise;
+        const generation = this.#schema.generation;
+        // A fetch started before the metadata was invalidated is not joined
+        if (this.#pendingMetadata?.generation !== generation) {
+            const pending = {
+                generation,
+                promise: this.#setMetadata(generation).finally(() => {
+                    if (this.#pendingMetadata === pending) {
+                        this.#pendingMetadata = undefined;
+                    }
+                }),
+            };
+            this.#pendingMetadata = pending;
+        }
+        return this.#pendingMetadata.promise;
     }
     // DO NOT use directly, use #updateMetadata instead
-    async #setMetadata() {
+    async #setMetadata(generation) {
         const [labels, relationshipTypes, propertyKeys] = await Promise.all([
             this.#client.roQuery(this.#name, "CALL db.labels()", undefined, false),
             this.#client.roQuery(this.#name, "CALL db.relationshipTypes()", undefined, false),
             this.#client.roQuery(this.#name, "CALL db.propertyKeys()", undefined, false),
         ]);
-        this.#metadata = {
+        const metadata = {
             labels: this.#cleanMetadataArray(labels.data),
             relationshipTypes: this.#cleanMetadataArray(relationshipTypes.data),
             propertyKeys: this.#cleanMetadataArray(propertyKeys.data),
         };
-        return this.#metadata;
+        // The caller's reply predates any reset, so it still gets these names,
+        // but they are only cached if the graph was not deleted meanwhile
+        if (generation === this.#schema.generation) {
+            this.#metadata = { generation, names: metadata };
+        }
+        return metadata;
     }
     #cleanMetadataArray(arr) {
         return arr.map(([value]) => value);
     }
     #getMetadata(key, id) {
-        return this.#metadata?.[key][id] ?? this.#getMetadataAsync(key, id);
+        const metadata = this.#metadata?.generation === this.#schema.generation
+            ? this.#metadata.names
+            : undefined;
+        return metadata?.[key][id] ?? this.#getMetadataAsync(key, id);
     }
     // DO NOT use directly, use #getMetadata instead
     async #getMetadataAsync(key, id) {
@@ -121,53 +159,53 @@ class Graph {
     }
     #parseValue([valueType, value], promises) {
         switch (valueType) {
-            case GraphValueTypes.NULL:
+            case enums_1.GraphValueTypes.NULL:
                 return null;
-            case GraphValueTypes.STRING:
-            case GraphValueTypes.INTEGER:
+            case enums_1.GraphValueTypes.STRING:
+            case enums_1.GraphValueTypes.INTEGER:
                 return value;
-            case GraphValueTypes.BOOLEAN:
+            case enums_1.GraphValueTypes.BOOLEAN:
                 return value === "true";
-            case GraphValueTypes.DOUBLE:
+            case enums_1.GraphValueTypes.DOUBLE:
                 return parseFloat(value);
-            case GraphValueTypes.ARRAY:
+            case enums_1.GraphValueTypes.ARRAY:
                 return value.map((x) => this.#parseValue(x, promises));
-            case GraphValueTypes.EDGE:
+            case enums_1.GraphValueTypes.EDGE:
                 return this.#parseEdge(value, promises);
-            case GraphValueTypes.NODE:
+            case enums_1.GraphValueTypes.NODE:
                 return this.#parseNode(value, promises);
-            case GraphValueTypes.PATH:
+            case enums_1.GraphValueTypes.PATH:
                 return {
                     nodes: value[0][1].map(([, node]) => this.#parseNode(node, promises)),
                     edges: value[1][1].map(([, edge]) => this.#parseEdge(edge, promises)),
                 };
-            case GraphValueTypes.MAP: {
+            case enums_1.GraphValueTypes.MAP: {
                 const map = {};
                 for (let i = 0; i < value.length; i++) {
                     map[value[i++]] = this.#parseValue(value[i], promises);
                 }
                 return map;
             }
-            case GraphValueTypes.POINT:
+            case enums_1.GraphValueTypes.POINT:
                 return {
                     latitude: parseFloat(value[0]),
                     longitude: parseFloat(value[1]),
                 };
-            case GraphValueTypes.VECTORF32:
+            case enums_1.GraphValueTypes.VECTORF32:
                 return value.map((x) => Number(x));
-            case GraphValueTypes.DATETIME:
+            case enums_1.GraphValueTypes.DATETIME:
                 return polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000)
                     .toZonedDateTimeISO("UTC")
                     .toPlainDateTime();
-            case GraphValueTypes.DATE:
+            case enums_1.GraphValueTypes.DATE:
                 return polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000)
                     .toZonedDateTimeISO("UTC")
                     .toPlainDate();
-            case GraphValueTypes.TIME:
+            case enums_1.GraphValueTypes.TIME:
                 return polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000)
                     .toZonedDateTimeISO("UTC")
                     .toPlainTime();
-            case GraphValueTypes.DURATION:
+            case enums_1.GraphValueTypes.DURATION:
                 const time = polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000);
                 const epoch = polyfill_1.Temporal.Instant.fromEpochMilliseconds(0);
                 return epoch

package/dist/src/types/cluster-graph-connection.d.ts

@@ -0,0 +1,5 @@
+import type { RedisClusterType, RedisFunctions, RedisScripts } from '@redis/client';
+import type commands from '../commands';
+export type ClusterGraphConnection = RedisClusterType<{
+    falkordb: typeof commands;
+}, RedisFunctions, RedisScripts, 2>;

package/dist/src/types/cluster-graph-connection.js

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

package/dist/src/types/config-item.d.ts

@@ -0,0 +1,4 @@
+export type ConfigItem = [
+    configKey: string,
+    value: number
+];

package/dist/src/types/config-item.js

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

package/dist/src/types/falkordb-options.d.ts

@@ -0,0 +1,65 @@
+import type { SocketOptions } from './socket-options';
+export interface FalkorDBOptions {
+    /**
+     * `falkor[s]://[[username][:password]@][host][:port][/db-number]`
+     */
+    url?: string;
+    /**
+     * Socket connection properties
+     */
+    socket?: SocketOptions;
+    /**
+     * Server hostname, shorthand for `socket.host`.
+     * Ignored when `url` or `socket.host` is provided.
+     */
+    host?: string;
+    /**
+     * Server port, shorthand for `socket.port`.
+     * Ignored when `url` or `socket.port` is provided.
+     */
+    port?: number;
+    /**
+     * Sentinel only. Resend write commands to the new master when the
+     * connection is lost while waiting for their reply, e.g. during a master
+     * hand-over. 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 (such as ones rejected with `READONLY`), are always resent.
+     * @default false
+     */
+    retryWritesOnConnectionLoss?: boolean;
+    /**
+     * ACL username ([see ACL guide](https://redis.io/topics/acl))
+     */
+    username?: string;
+    /**
+     * ACL password or the old "--requirepass" password
+     */
+    password?: string;
+    /**
+     * Client name ([see `CLIENT SETNAME`](https://redis.io/commands/client-setname))
+     */
+    name?: string;
+    /**
+     * Connect in [`READONLY`](https://redis.io/commands/readonly) mode
+     */
+    readonly?: boolean;
+    /**
+     * Send `PING` command at interval (in ms).
+     * Useful with Redis deployments that do not use TCP Keep-Alive.
+     */
+    pingInterval?: number;
+    /**
+     * If set to true, disables sending client identifier (user-agent like message) to the redis server
+     */
+    disableClientInfo?: boolean;
+    /**
+     * Tag to append to library name that is sent to the Redis server
+     */
+    clientInfoTag?: string;
+    /**
+     * RESP protocol version. Only RESP 2 is supported: under RESP 3 node-redis rewrites
+     * module map replies into objects, which does not match the reply shapes this client
+     * parses and publishes types for. Passing anything else throws.
+     */
+    RESP?: 2;
+}

package/dist/src/types/falkordb-options.js

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

package/dist/src/types/graph-metadata.d.ts

@@ -0,0 +1,5 @@
+export interface GraphMetadata {
+    labels: Array<string>;
+    relationshipTypes: Array<string>;
+    propertyKeys: Array<string>;
+}

package/dist/src/types/graph-metadata.js

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

package/dist/src/types/graph-raw-value.d.ts

@@ -0,0 +1,29 @@
+import type { GraphValueTypes } from '../enums';
+export type GraphEntityRawProperties = Array<[id: number, ...value: GraphRawValue]>;
+export type GraphEdgeRawValue = [
+    GraphValueTypes.EDGE,
+    [
+        id: number,
+        relationshipTypeId: number,
+        sourceId: number,
+        destinationId: number,
+        properties: GraphEntityRawProperties
+    ]
+];
+export type GraphNodeRawValue = [
+    GraphValueTypes.NODE,
+    [
+        id: number,
+        labelIds: Array<number>,
+        properties: GraphEntityRawProperties
+    ]
+];
+export type GraphPathRawValue = [
+    GraphValueTypes.PATH,
+    [
+        nodes: [GraphValueTypes.ARRAY, Array<GraphNodeRawValue>],
+        edges: [GraphValueTypes.ARRAY, Array<GraphEdgeRawValue>]
+    ]
+];
+export type GraphMapRawValue = [GraphValueTypes.MAP, Array<string | GraphRawValue>];
+export type GraphRawValue = [GraphValueTypes.NULL, null] | [GraphValueTypes.STRING, string] | [GraphValueTypes.INTEGER, number] | [GraphValueTypes.BOOLEAN, string] | [GraphValueTypes.DOUBLE, string] | [GraphValueTypes.ARRAY, Array<GraphRawValue>] | GraphEdgeRawValue | GraphNodeRawValue | GraphPathRawValue | GraphMapRawValue | [GraphValueTypes.POINT, [latitude: string, longitude: string]] | [GraphValueTypes.VECTORF32, number[]] | [GraphValueTypes.DATETIME, number] | [GraphValueTypes.DATE, number] | [GraphValueTypes.TIME, number] | [GraphValueTypes.DURATION, number];

package/dist/src/types/graph-raw-value.js

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

package/dist/src/types/graph-value.d.ts

@@ -0,0 +1,29 @@
+import type { Temporal } from '@js-temporal/polyfill';
+import type { QueryReply } from './query-reply';
+export type GraphEntityProperties = Record<string, GraphValue>;
+export interface GraphEdge {
+    id: number;
+    relationshipType: string;
+    sourceId: number;
+    destinationId: number;
+    properties: GraphEntityProperties;
+}
+export interface GraphNode {
+    id: number;
+    labels: Array<string>;
+    properties: GraphEntityProperties;
+}
+export interface GraphPath {
+    nodes: Array<GraphNode>;
+    edges: Array<GraphEdge>;
+}
+export type GraphMap = {
+    [key: string]: GraphValue;
+};
+export type GraphValue = null | string | number | boolean | Array<GraphValue> | GraphEdge | GraphNode | GraphPath | GraphMap | {
+    latitude: string;
+    longitude: string;
+} | number[] | Temporal.PlainDateTime | Temporal.PlainDate | Temporal.PlainTime | Temporal.Duration;
+export type GraphReply<T> = Omit<QueryReply, "headers" | "data"> & {
+    data?: Array<T>;
+};

package/dist/src/types/graph-value.js

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

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

@@ -0,0 +1,16 @@
+export * from './cluster-graph-connection';
+export * from './config-item';
+export * from './falkordb-options';
+export * from './graph-metadata';
+export * from './graph-raw-value';
+export * from './graph-value';
+export * from './memory-usage';
+export * from './net-socket-options';
+export * from './query-options';
+export * from './query-reply';
+export * from './single-graph-connection';
+export * from './slow-log';
+export * from './socket-options';
+export * from './tls-socket-options';
+export * from './typed-redis-client-options';
+export * from './udf-list';