falkordb 6.9.2 → 7.0.0

package/dist/src/graph.js

@@ -6,25 +6,107 @@ 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");
+const query_statistics_1 = require("./query-statistics");
+const execution_plan_1 = require("./execution-plan");
+const commands_1 = require("./commands");
+// The error `CREATE INDEX` fails with when a property is already indexed
+const ALREADY_INDEXED = /^Attribute '.*' is already indexed$/;
+// Turns create{Node,Edge}VectorIndex's options into the index's OPTIONS map
+function vectorIndexOptions(options) {
+    // Catches the positional `(label, dimension, similarityFunction, ...)` form
+    // removed in v7, which plain JavaScript callers could still use
+    if (options === null || typeof options !== "object") {
+        throw new TypeError("Vector index options must be an object, e.g. { dimension: 768, similarityFunction: 'cosine' }");
+    }
+    if (typeof options.dimension !== "number") {
+        throw new TypeError("Vector index options must include a numeric dimension");
+    }
+    const { similarityFunction = "euclidean", ...rest } = options;
+    const result = { similarityFunction };
+    for (const [key, value] of Object.entries(rest)) {
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
+}
+// The names GRAPH.CONSTRAINT accepts (`PROPERTY_NAME_PATTERN` in FalkorDB's
+// src/commands/cmd_constraint.c), stricter than what Cypher can quote
+const CONSTRAINT_NAME = /^[a-zA-Z_][a-zA-Z0-9_$]*$/;
+function validateConstraintName(kind, name) {
+    if (!CONSTRAINT_NAME.test(name)) {
+        throw new TypeError(`${kind} name ${JSON.stringify(name)} is invalid for a constraint: ` +
+            "start with a letter or _, followed by letters, digits, _ or $");
+    }
+}
+// The pattern an index is defined on, with the label quoted so that names
+// such as `Product Type` work
+function indexPattern(entityType, label) {
+    const name = (0, commands_1.escapeIdentifier)(label, "label");
+    return entityType === "NODE" ? `(e:${name})` : `()-[e:${name}]->()`;
+}
+// export type GraphConnection = SingleGraphConnection | ClusterGraphConnection;
+// A read is checked against the schema version on its first attempts, then
+// sent once without a version, so that a schema changing faster than it can
+// be read cannot keep it retrying. Four checked attempts cover a lagging
+// replica's version, the master's, and a further change on the master.
+const MAX_VERSIONED_READS = 5;
+// Unknown value types already warned about, so each is reported only once
+const warnedUnknownValueTypes = new Set();
+function warnUnknownValueType(valueType) {
+    if (warnedUnknownValueTypes.has(valueType))
+        return;
+    warnedUnknownValueTypes.add(valueType);
+    console.warn(`FalkorDB: unknown value type ${valueType} in reply, returning null`);
+}
 class Graph {
     #client;
     #name;
     #metadata;
     #schema;
     #onDelete;
+    #selectGraph;
+    // Integers are read from their exact digits and returned as bigint
+    #exactIntegers;
     constructor(client, name, cache) {
         this.#client = client;
         this.#name = name;
         this.#schema = cache?.schema ?? { generation: 0, version: 0 };
         this.#onDelete = cache?.onDelete;
+        this.#selectGraph = cache?.selectGraph;
+        this.#exactIntegers = cache?.integers === "bigint";
+    }
+    /** The graph's name (its Redis key) */
+    get name() {
+        return this.#name;
     }
     async query(query, options) {
-        const reply = await this.#withSchemaVersion((version) => this.#client.query(this.#name, query, options, true, version));
+        const reply = await this.#withSchemaVersion((version) => this.#client.query(this.#name, query, options, true, version, this.#exactIntegers));
         return this.#parseReply(reply);
     }
     async roQuery(query, options) {
-        const reply = await this.#withSchemaVersion((version) => this.#client.roQuery(this.#name, query, options, true, version));
-        return this.#parseReply(reply);
+        // Reads may be served by any node until one of them, or the master the
+        // names come from, rejects the schema version
+        let primary = false;
+        for (let attempt = 1;; attempt++) {
+            const version = attempt < MAX_VERSIONED_READS ? this.#schema.version : undefined;
+            try {
+                const reply = await this.#client.roQuery(this.#name, query, options, true, version, primary, this.#exactIntegers);
+                return await this.#parseReply(reply, version);
+            }
+            catch (err) {
+                if (!(err instanceof errors_1.SchemaVersionMismatchError))
+                    throw err;
+                // A replica can lag behind the master, even keep a graph the master
+                // deleted and recreated. Read from the master instead, still checked
+                // against the version, so that its reply matches its names even if
+                // the schema changes meanwhile. A version reported by a replica is
+                // replaced by the master's when the master rejects it in turn. Reads
+                // change nothing, so running one again is safe.
+                this.clearMetadataCache();
+                this.#schema.version = err.version;
+                primary = true;
+            }
+        }
     }
     async #withSchemaVersion(run) {
         try {
@@ -64,11 +146,20 @@ class Graph {
         this.#schema.generation++;
         this.#metadata = undefined;
     }
-    async explain(query) {
-        return this.#client.explain(this.#name, query);
+    /**
+     * Returns the query's execution plan as an operation tree, without running
+     * the query. The lines the server returned are kept in `steps`.
+     */
+    async explain(query, options) {
+        return new execution_plan_1.ExecutionPlan(await this.#client.explain(this.#name, query, options));
     }
-    async profile(query) {
-        return this.#client.profile(this.#name, query);
+    /**
+     * Runs the query and returns its execution plan as an operation tree, each
+     * operation annotated with its `recordsProduced` and `executionTime`. The
+     * lines the server returned are kept in `steps`.
+     */
+    async profile(query, options) {
+        return new execution_plan_1.ExecutionPlan(await this.#client.profile(this.#name, query, options));
     }
     async memoryUsage(options) {
         return this.#client.memoryUsage(this.#name, options);
@@ -76,23 +167,157 @@ class Graph {
     async slowLog() {
         return this.#client.slowLog(this.#name);
     }
+    /** Clears the graph's slow log (`GRAPH.SLOWLOG <graph> RESET`) */
+    async slowLogReset() {
+        return this.#client.slowLogReset(this.#name);
+    }
+    /**
+     * Calls a procedure, e.g. `callProcedure('db.idx.fulltext.queryNodes', ['Movie', 'Jungle'])`.
+     * The arguments are sent as query parameters, so they need no escaping.
+     * Runs as a read-only query unless `readOnly` is `false`.
+     */
+    async callProcedure(procedure, args = [], options = {}) {
+        const params = {};
+        const placeholders = args.map((arg, i) => {
+            params[`param${i}`] = arg;
+            return `$param${i}`;
+        });
+        let query = `CALL ${procedure}(${placeholders.join(",")})`;
+        if (options.yields?.length) {
+            query += ` YIELD ${options.yields.join(",")}`;
+        }
+        const queryOptions = { TIMEOUT: options.timeout };
+        if (args.length)
+            queryOptions.params = params;
+        return options.readOnly === false
+            ? this.query(query, queryOptions)
+            : this.roQuery(query, queryOptions);
+    }
+    /** Lists the graph's indexes (`CALL db.indexes()`) */
+    async listIndices() {
+        const reply = await this.callProcedure("db.indexes");
+        return (reply.data ?? []).map(({ entitytype, ...index }) => ({
+            ...index,
+            entityType: entitytype,
+        }));
+    }
+    /** Lists the graph's constraints and their status (`CALL db.constraints()`) */
+    async listConstraints() {
+        const reply = await this.callProcedure("db.constraints");
+        return (reply.data ?? []).map(({ entitytype, ...constraint }) => ({
+            ...constraint,
+            entityType: entitytype,
+        }));
+    }
+    /**
+     * Creates a constraint (`GRAPH.CONSTRAINT CREATE`).
+     *
+     * A unique constraint requires a range index on each of its properties, so
+     * for `ConstraintType.UNIQUE` this first creates that index on every
+     * property that is not indexed yet (an existing index is reused). Mandatory
+     * constraints need no index and create none.
+     *
+     * The constraint is enforced asynchronously: the server accepts it before
+     * checking the existing data, so poll `listConstraints()` until its status
+     * is `OPERATIONAL` (or `FAILED` if existing entities violate it).
+     */
     async constraintCreate(constraintType, entityType, label, ...properties) {
+        // Checked before the supporting indexes are created, so that a name the
+        // server rejects for a constraint leaves no index behind
+        validateConstraintName("Label", label);
+        properties.forEach((property) => validateConstraintName("Property", property));
+        if (constraintType === enums_1.ConstraintType.UNIQUE) {
+            await this.#ensureRangeIndexes(entityType === enums_1.EntityType.RELATIONSHIP ? "EDGE" : "NODE", label, properties);
+        }
         return this.#client.constraintCreate(this.#name, constraintType, entityType, label, ...properties);
     }
     async constraintDrop(constraintType, entityType, label, ...properties) {
         return this.#client.constraintDrop(this.#name, constraintType, entityType, label, ...properties);
     }
+    /**
+     * Creates a unique constraint on nodes, together with the range index it
+     * requires on each property. Enforced asynchronously, see `constraintCreate`.
+     */
+    async createNodeUniqueConstraint(label, ...properties) {
+        return this.constraintCreate(enums_1.ConstraintType.UNIQUE, enums_1.EntityType.NODE, label, ...properties);
+    }
+    /**
+     * Creates a unique constraint on relationships, together with the range
+     * index it requires on each property. Enforced asynchronously, see
+     * `constraintCreate`.
+     */
+    async createEdgeUniqueConstraint(relation, ...properties) {
+        return this.constraintCreate(enums_1.ConstraintType.UNIQUE, enums_1.EntityType.RELATIONSHIP, relation, ...properties);
+    }
+    /**
+     * Creates a mandatory constraint on nodes. Enforced asynchronously, see
+     * `constraintCreate`.
+     */
+    async createNodeMandatoryConstraint(label, ...properties) {
+        return this.constraintCreate(enums_1.ConstraintType.MANDATORY, enums_1.EntityType.NODE, label, ...properties);
+    }
+    /**
+     * Creates a mandatory constraint on relationships. Enforced asynchronously,
+     * see `constraintCreate`.
+     */
+    async createEdgeMandatoryConstraint(relation, ...properties) {
+        return this.constraintCreate(enums_1.ConstraintType.MANDATORY, enums_1.EntityType.RELATIONSHIP, relation, ...properties);
+    }
+    /** Drops a unique constraint on nodes; its supporting range index is kept */
+    async dropNodeUniqueConstraint(label, ...properties) {
+        return this.constraintDrop(enums_1.ConstraintType.UNIQUE, enums_1.EntityType.NODE, label, ...properties);
+    }
+    /** Drops a unique constraint on relationships; its supporting range index is kept */
+    async dropEdgeUniqueConstraint(relation, ...properties) {
+        return this.constraintDrop(enums_1.ConstraintType.UNIQUE, enums_1.EntityType.RELATIONSHIP, relation, ...properties);
+    }
+    async dropNodeMandatoryConstraint(label, ...properties) {
+        return this.constraintDrop(enums_1.ConstraintType.MANDATORY, enums_1.EntityType.NODE, label, ...properties);
+    }
+    async dropEdgeMandatoryConstraint(relation, ...properties) {
+        return this.constraintDrop(enums_1.ConstraintType.MANDATORY, enums_1.EntityType.RELATIONSHIP, relation, ...properties);
+    }
+    // Indexes each property separately: a single CREATE INDEX over several
+    // properties fails as a whole if any of them is already indexed
+    async #ensureRangeIndexes(entityType, label, properties) {
+        for (const property of properties) {
+            try {
+                await this.createTypedIndex("RANGE", entityType, label, [property]);
+            }
+            catch (err) {
+                if (!(err instanceof Error && ALREADY_INDEXED.test(err.message))) {
+                    throw err;
+                }
+            }
+        }
+    }
+    /**
+     * Copies the graph to `destGraph` (`GRAPH.COPY`) and returns the copy: for
+     * a graph from `selectGraph`, the instance `selectGraph(destGraph)` returns.
+     */
     async copy(destGraph) {
-        return this.#client.copy(this.#name, destGraph);
+        await this.#client.copy(this.#name, destGraph);
+        const copy = this.#selectGraph?.(destGraph);
+        if (!copy) {
+            return new Graph(this.#client, destGraph, {
+                integers: this.#exactIntegers ? "bigint" : "number",
+            });
+        }
+        // Names cached for a graph that had this name before do not apply
+        copy.clearMetadataCache();
+        return copy;
     }
     #pendingMetadata;
-    #updateMetadata() {
+    #updateMetadata(version) {
         const generation = this.#schema.generation;
-        // A fetch started before the metadata was invalidated is not joined
-        if (this.#pendingMetadata?.generation !== generation) {
+        // A fetch started before the metadata was invalidated, or for another
+        // schema version, is not joined
+        if (this.#pendingMetadata?.generation !== generation ||
+            this.#pendingMetadata.version !== version) {
             const pending = {
                 generation,
-                promise: this.#setMetadata(generation).finally(() => {
+                version,
+                promise: this.#setMetadata(generation, version).finally(() => {
                     if (this.#pendingMetadata === pending) {
                         this.#pendingMetadata = undefined;
                     }
@@ -103,11 +328,15 @@ class Graph {
         return this.#pendingMetadata.promise;
     }
     // DO NOT use directly, use #updateMetadata instead
-    async #setMetadata(generation) {
+    async #setMetadata(generation, version) {
+        // Fetched from the master: a reply served by it (every write's) can use
+        // names a lagging replica does not have yet. With a version, the master
+        // rejects the fetch unless its schema is the one the reply was checked
+        // against, e.g. one a replica served from a graph since recreated.
         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.#client.roQuery(this.#name, "CALL db.labels()", undefined, false, version, true),
+            this.#client.roQuery(this.#name, "CALL db.relationshipTypes()", undefined, false, version, true),
+            this.#client.roQuery(this.#name, "CALL db.propertyKeys()", undefined, false, version, true),
         ]);
         const metadata = {
             labels: this.#cleanMetadataArray(labels.data),
@@ -117,72 +346,86 @@ class Graph {
         // 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 };
+            this.#metadata = { generation, version, names: metadata };
         }
         return metadata;
     }
     #cleanMetadataArray(arr) {
         return arr.map(([value]) => value);
     }
-    #getMetadata(key, id) {
-        const metadata = this.#metadata?.generation === this.#schema.generation
+    #getMetadata(key, id, version) {
+        const metadata = this.#metadata?.generation === this.#schema.generation &&
+            (version === undefined || this.#metadata.version === version)
             ? this.#metadata.names
             : undefined;
-        return metadata?.[key][id] ?? this.#getMetadataAsync(key, id);
+        return metadata?.[key][id] ?? this.#getMetadataAsync(key, id, version);
     }
     // DO NOT use directly, use #getMetadata instead
-    async #getMetadataAsync(key, id) {
-        const value = (await this.#updateMetadata())[key][id];
+    async #getMetadataAsync(key, id, version) {
+        const value = (await this.#updateMetadata(version))[key][id];
         if (value === undefined)
             throw new Error(`Cannot find value from ${key}[${id}]`);
         return value;
     }
-    async #parseReply(reply) {
+    async #parseReply(reply, version) {
+        // The raw statistic lines are replaced by their parsed form
+        const stats = (0, query_statistics_1.parseQueryStatistics)(reply.metadata);
         if (!reply.data)
-            return reply;
-        const promises = [], parsed = {
-            metadata: reply.metadata,
+            return { stats };
+        // Compact replies describe each column as [type, name]
+        const headers = reply.headers.map(([, name]) => name);
+        const ctx = { promises: [], version }, parsed = {
+            headers,
+            stats,
             data: reply.data.map((row) => {
                 const data = {};
                 if (Array.isArray(row)) {
                     for (let i = 0; i < row.length; i++) {
                         const value = row[i];
-                        data[reply.headers[i][1]] = this.#parseValue(value, promises);
+                        data[headers[i]] = this.#parseValue(value, ctx);
                     }
                 }
                 return data;
             }),
         };
-        if (promises.length)
-            await Promise.all(promises);
+        if (ctx.promises.length)
+            await Promise.all(ctx.promises);
         return parsed;
     }
-    #parseValue([valueType, value], promises) {
+    // With exact integers every integer in a reply, type codes and ids
+    // included, arrives as a string of its digits; Number() undoes that and
+    // leaves a number unchanged.
+    #parseValue([valueType, value], ctx) {
+        if (typeof valueType === "string") {
+            return this.#parseValue([Number(valueType), value], ctx);
+        }
         switch (valueType) {
             case enums_1.GraphValueTypes.NULL:
                 return null;
             case enums_1.GraphValueTypes.STRING:
-            case enums_1.GraphValueTypes.INTEGER:
                 return value;
+            case enums_1.GraphValueTypes.INTEGER:
+                // Digits only arrive as a string when integers are read exactly
+                return typeof value === "string" ? BigInt(value) : value;
             case enums_1.GraphValueTypes.BOOLEAN:
                 return value === "true";
             case enums_1.GraphValueTypes.DOUBLE:
                 return parseFloat(value);
             case enums_1.GraphValueTypes.ARRAY:
-                return value.map((x) => this.#parseValue(x, promises));
+                return value.map((x) => this.#parseValue(x, ctx));
             case enums_1.GraphValueTypes.EDGE:
-                return this.#parseEdge(value, promises);
+                return this.#parseEdge(value, ctx);
             case enums_1.GraphValueTypes.NODE:
-                return this.#parseNode(value, promises);
+                return this.#parseNode(value, ctx);
             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)),
+                    nodes: value[0][1].map(([, node]) => this.#parseNode(node, ctx)),
+                    edges: value[1][1].map(([, edge]) => this.#parseEdge(edge, ctx)),
                 };
             case enums_1.GraphValueTypes.MAP: {
                 const map = {};
                 for (let i = 0; i < value.length; i++) {
-                    map[value[i++]] = this.#parseValue(value[i], promises);
+                    map[value[i++]] = this.#parseValue(value[i], ctx);
                 }
                 return map;
             }
@@ -194,19 +437,19 @@ class Graph {
             case enums_1.GraphValueTypes.VECTORF32:
                 return value.map((x) => Number(x));
             case enums_1.GraphValueTypes.DATETIME:
-                return polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000)
+                return polyfill_1.Temporal.Instant.fromEpochMilliseconds(Number(value) * 1000)
                     .toZonedDateTimeISO("UTC")
                     .toPlainDateTime();
             case enums_1.GraphValueTypes.DATE:
-                return polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000)
+                return polyfill_1.Temporal.Instant.fromEpochMilliseconds(Number(value) * 1000)
                     .toZonedDateTimeISO("UTC")
                     .toPlainDate();
             case enums_1.GraphValueTypes.TIME:
-                return polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000)
+                return polyfill_1.Temporal.Instant.fromEpochMilliseconds(Number(value) * 1000)
                     .toZonedDateTimeISO("UTC")
                     .toPlainTime();
             case enums_1.GraphValueTypes.DURATION:
-                const time = polyfill_1.Temporal.Instant.fromEpochMilliseconds(value * 1000);
+                const time = polyfill_1.Temporal.Instant.fromEpochMilliseconds(Number(value) * 1000);
                 const epoch = polyfill_1.Temporal.Instant.fromEpochMilliseconds(0);
                 return epoch
                     .toZonedDateTimeISO("UTC")
@@ -214,48 +457,51 @@ class Graph {
                     largestUnit: "years",
                 });
             default:
-                throw new Error(`unknown scalar type: ${valueType}`);
+                // A type this client does not know yet (e.g. one added by a newer
+                // server) is read as null rather than failing the whole query
+                warnUnknownValueType(valueType);
+                return null;
         }
     }
-    #parseEdge([id, relationshipTypeId, sourceId, destinationId, properties,], promises) {
+    #parseEdge([id, relationshipTypeId, sourceId, destinationId, properties,], ctx) {
         const edge = {
-            id,
-            sourceId,
-            destinationId,
-            properties: this.#parseProperties(properties, promises),
+            id: Number(id),
+            sourceId: Number(sourceId),
+            destinationId: Number(destinationId),
+            properties: this.#parseProperties(properties, ctx),
         };
-        const relationshipType = this.#getMetadata("relationshipTypes", relationshipTypeId);
+        const relationshipType = this.#getMetadata("relationshipTypes", Number(relationshipTypeId), ctx.version);
         if (relationshipType instanceof Promise) {
-            promises.push(relationshipType.then((value) => (edge.relationshipType = value)));
+            ctx.promises.push(relationshipType.then((value) => (edge.relationshipType = value)));
         }
         else {
             edge.relationshipType = relationshipType;
         }
         return edge;
     }
-    #parseNode([id, labelIds, properties], promises) {
+    #parseNode([id, labelIds, properties], ctx) {
         const labels = new Array(labelIds.length);
         for (let i = 0; i < labelIds.length; i++) {
-            const value = this.#getMetadata("labels", labelIds[i]);
+            const value = this.#getMetadata("labels", Number(labelIds[i]), ctx.version);
             if (value instanceof Promise) {
-                promises.push(value.then((value) => (labels[i] = value)));
+                ctx.promises.push(value.then((value) => (labels[i] = value)));
             }
             else {
                 labels[i] = value;
             }
         }
         return {
-            id,
+            id: Number(id),
             labels,
-            properties: this.#parseProperties(properties, promises),
+            properties: this.#parseProperties(properties, ctx),
         };
     }
-    #parseProperties(raw, promises) {
+    #parseProperties(raw, ctx) {
         const parsed = {};
         for (const [id, type, value] of raw) {
-            const parsedValue = this.#parseValue([type, value], promises), key = this.#getMetadata("propertyKeys", id);
+            const parsedValue = this.#parseValue([type, value], ctx), key = this.#getMetadata("propertyKeys", Number(id), ctx.version);
             if (key instanceof Promise) {
-                promises.push(key.then((key) => (parsed[key] = parsedValue)));
+                ctx.promises.push(key.then((key) => (parsed[key] = parsedValue)));
             }
             else {
                 parsed[key] = parsedValue;
@@ -264,12 +510,12 @@ class Graph {
         return parsed;
     }
     async createTypedIndex(idxType, entityType, label, properties, options) {
-        const pattern = entityType === "NODE" ? `(e:${label})` : `()-[e:${label}]->()`;
+        const pattern = indexPattern(entityType, label);
         if (idxType === "RANGE") {
             idxType = "";
         }
         let query = `CREATE ${idxType ? idxType + " " : ""}INDEX FOR ${pattern} ON (${properties
-            .map((prop) => `e.${prop}`)
+            .map((prop) => `e.${(0, commands_1.escapeIdentifier)(prop, "property name")}`)
             .join(", ")})`;
         if (options) {
             const optionsMap = Object.entries(options)
@@ -277,7 +523,7 @@ class Graph {
                 .join(", ");
             query += ` OPTIONS {${optionsMap}}`;
         }
-        return this.#client.query(this.#name, query);
+        return this.query(query);
     }
     async createNodeRangeIndex(label, ...properties) {
         return this.createTypedIndex("RANGE", "NODE", label, properties);
@@ -285,12 +531,12 @@ class Graph {
     async createNodeFulltextIndex(label, ...properties) {
         return this.createTypedIndex("FULLTEXT", "NODE", label, properties);
     }
-    async createNodeVectorIndex(label, dim = 0, similarityFunction = "euclidean", ...properties) {
-        const options = {
-            dimension: dim,
-            similarityFunction: similarityFunction,
-        };
-        return await this.createTypedIndex("VECTOR", "NODE", label, properties, options);
+    /**
+     * Creates a vector index, e.g.
+     * `createNodeVectorIndex(label, { dimension: 768, similarityFunction: 'cosine' }, 'embedding')`.
+     */
+    async createNodeVectorIndex(label, options, ...properties) {
+        return this.createTypedIndex("VECTOR", "NODE", label, properties, vectorIndexOptions(options));
     }
     async createEdgeRangeIndex(label, ...properties) {
         return this.createTypedIndex("RANGE", "EDGE", label, properties);
@@ -298,20 +544,20 @@ class Graph {
     async createEdgeFulltextIndex(label, ...properties) {
         return this.createTypedIndex("FULLTEXT", "EDGE", label, properties);
     }
-    async createEdgeVectorIndex(label, dim = 0, similarityFunction = "euclidean", ...properties) {
-        const options = {
-            dimension: dim,
-            similarityFunction: similarityFunction,
-        };
-        return await this.createTypedIndex("VECTOR", "EDGE", label, properties, options);
+    /**
+     * Creates a vector index, e.g.
+     * `createEdgeVectorIndex(label, { dimension: 768, similarityFunction: 'cosine' }, 'embedding')`.
+     */
+    async createEdgeVectorIndex(label, options, ...properties) {
+        return this.createTypedIndex("VECTOR", "EDGE", label, properties, vectorIndexOptions(options));
     }
     async dropTypedIndex(idxType, entityType, label, attribute) {
-        const pattern = entityType === "NODE" ? `(e:${label})` : `()-[e:${label}]->()`;
+        const pattern = indexPattern(entityType, label);
         if (idxType === "RANGE") {
             idxType = "";
         }
-        let query = `DROP ${idxType ? idxType + " " : ""}INDEX FOR ${pattern} ON (e.${attribute})`;
-        return this.#client.query(this.#name, query);
+        let query = `DROP ${idxType ? idxType + " " : ""}INDEX FOR ${pattern} ON (e.${(0, commands_1.escapeIdentifier)(attribute, "property name")})`;
+        return this.query(query);
     }
     async dropNodeRangeIndex(label, attribute) {
         return this.dropTypedIndex("RANGE", "NODE", label, attribute);

package/dist/src/query-statistics.d.ts

@@ -0,0 +1,6 @@
+import type { QueryStatistics } from "./types";
+/**
+ * Parses the statistic lines of a query reply's metadata, e.g.
+ * `"Nodes created: 1"`. Unknown or malformed lines are ignored.
+ */
+export declare function parseQueryStatistics(metadata?: ReadonlyArray<string>): QueryStatistics;

package/dist/src/query-statistics.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQueryStatistics = parseQueryStatistics;
+// Statistic lines as the server words them (`ResultSet_EmitCompactStats` in
+// FalkorDB's src/resultset/formatters/resultset_replycompact.c)
+const COUNTERS = {
+    "Labels added": "labelsAdded",
+    "Labels removed": "labelsRemoved",
+    "Nodes created": "nodesCreated",
+    "Nodes deleted": "nodesDeleted",
+    "Properties set": "propertiesSet",
+    "Properties removed": "propertiesRemoved",
+    "Relationships created": "relationshipsCreated",
+    "Relationships deleted": "relationshipsDeleted",
+    "Indices created": "indicesCreated",
+    "Indices deleted": "indicesDeleted",
+    "Constraints created": "constraintsCreated",
+    "Constraints deleted": "constraintsDeleted",
+    // e.g. "Query internal execution time: 0.123456 milliseconds"
+    "Query internal execution time": "queryInternalExecutionTime",
+};
+// e.g. "1", "0.123456 milliseconds"
+const STAT_VALUE = /^(\d+(?:\.\d+)?)(?: milliseconds)?$/;
+/**
+ * Parses the statistic lines of a query reply's metadata, e.g.
+ * `"Nodes created: 1"`. Unknown or malformed lines are ignored.
+ */
+function parseQueryStatistics(metadata = []) {
+    const stats = {
+        labelsAdded: 0,
+        labelsRemoved: 0,
+        nodesCreated: 0,
+        nodesDeleted: 0,
+        propertiesSet: 0,
+        propertiesRemoved: 0,
+        relationshipsCreated: 0,
+        relationshipsDeleted: 0,
+        indicesCreated: 0,
+        indicesDeleted: 0,
+        constraintsCreated: 0,
+        constraintsDeleted: 0,
+        cachedExecution: false,
+        queryInternalExecutionTime: 0,
+    };
+    for (const line of metadata) {
+        if (typeof line !== "string")
+            continue;
+        const separator = line.indexOf(":");
+        if (separator === -1)
+            continue;
+        const name = line.slice(0, separator).trim(), 
+        // The whole value must be a number, optionally followed by the unit of
+        // the execution time, so that a malformed line is ignored
+        match = STAT_VALUE.exec(line.slice(separator + 1).trim());
+        if (!match)
+            continue;
+        const value = Number(match[1]);
+        if (name === "Cached execution") {
+            stats.cachedExecution = value !== 0;
+        }
+        else if (Object.hasOwn(COUNTERS, name)) {
+            stats[COUNTERS[name]] = value;
+        }
+    }
+    return stats;
+}