falkordb 6.7.0 → 6.9.0

package/dist/src/clients/single.js

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

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

@@ -1,10 +1,6 @@
 import { CommandParser } from '@redis/client';
+import type { ConfigItem } from '../types';
 export declare const IS_READ_ONLY = true;
 export declare function parseCommand(parser: CommandParser, configKey: string): void;
 export declare function transformArguments(configKey: string): Array<string>;
-type ConfigItem = [
-    configKey: string,
-    value: number
-];
 export declare function transformReply(reply: unknown): ConfigItem | Array<ConfigItem>;
-export {};

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

@@ -1,12 +1,6 @@
 import { CommandParser } from '@redis/client';
-export declare enum ConstraintType {
-    MANDATORY = "MANDATORY",
-    UNIQUE = "UNIQUE"
-}
-export declare enum EntityType {
-    NODE = "NODE",
-    RELATIONSHIP = "RELATIONSHIP"
-}
+import { ConstraintType, EntityType } from '../enums';
+export { ConstraintType, EntityType };
 export declare function parseCommand(parser: CommandParser, key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): void;
 export declare function transformArguments(key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Array<string>;
 export declare function transformReply(reply: unknown): 'PENDING';

package/dist/src/commands/CONSTRAINT_CREATE.js

@@ -4,16 +4,9 @@ exports.EntityType = exports.ConstraintType = void 0;
 exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
-var ConstraintType;
-(function (ConstraintType) {
-    ConstraintType["MANDATORY"] = "MANDATORY";
-    ConstraintType["UNIQUE"] = "UNIQUE";
-})(ConstraintType || (exports.ConstraintType = ConstraintType = {}));
-var EntityType;
-(function (EntityType) {
-    EntityType["NODE"] = "NODE";
-    EntityType["RELATIONSHIP"] = "RELATIONSHIP";
-})(EntityType || (exports.EntityType = EntityType = {}));
+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; } });
 // 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);

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

@@ -1,5 +1,5 @@
 import { CommandParser } from '@redis/client';
-import { ConstraintType, EntityType } from "./CONSTRAINT_CREATE";
+import { ConstraintType, EntityType } from '../enums';
 export declare function parseCommand(parser: CommandParser, key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): void;
 export declare function transformArguments(key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Array<string>;
 export declare function transformReply(reply: unknown): 'OK';

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

@@ -1,8 +1,6 @@
 import { CommandParser } from '@redis/client';
-export interface MemoryUsageOptions {
-    SAMPLES?: number;
-}
+import type { MemoryUsageOptions, MemoryUsageReply } from '../types';
+export type { MemoryUsageOptions, MemoryUsageReply };
 export declare function parseCommand(parser: CommandParser, key: string, options?: MemoryUsageOptions): void;
 export declare function transformArguments(key: string, options?: MemoryUsageOptions): Array<string>;
-export type MemoryUsageReply = Array<string | number | MemoryUsageReply>;
 export declare function transformReply(reply: unknown): MemoryUsageReply;

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

@@ -1,26 +1,7 @@
 import { RedisArgument, CommandParser } from '@redis/client';
-import { QueryOptionsBackwardCompatible } from '.';
+import type { QueryOptionsBackwardCompatible, QueryRawReply, QueryReply } from '../types';
+export type { QueryReply };
 export declare const FIRST_KEY_INDEX = 1;
-export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): void;
-export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): Array<RedisArgument>;
-type Headers = Array<string>;
-type Data = Array<string | number | null | Data>;
-type Metadata = Array<string>;
-type QueryRawReply = [
-    headers: Headers,
-    data: Data,
-    metadata: Metadata
-] | [
-    metadata: Metadata
-];
-export type QueryReply = {
-    headers: undefined;
-    data: undefined;
-    metadata: Metadata;
-} | {
-    headers: Headers;
-    data: Data;
-    metadata: Metadata;
-};
+export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): void;
+export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): Array<RedisArgument>;
 export declare function transformReply(reply: QueryRawReply): QueryReply;
-export {};

package/dist/src/commands/QUERY.js

@@ -5,15 +5,25 @@ exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
 const _1 = require(".");
+const errors_1 = require("../errors");
 exports.FIRST_KEY_INDEX = 1;
-function parseCommand(parser, graph, query, options, compact) {
-    const args = (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact);
+function parseCommand(parser, graph, query, options, compact, version) {
+    const args = (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact, version);
     parser.push(...args);
 }
-function transformArguments(graph, query, options, compact) {
-    return (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact);
+function transformArguments(graph, query, options, compact, version) {
+    return (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact, version);
 }
 function transformReply(reply) {
+    // A query sent with a stale `version` is rejected with
+    // `[error "version mismatch", current version]` and not executed
+    const [first, second] = reply;
+    if (first instanceof Error) {
+        if (first.message === 'version mismatch') {
+            throw new errors_1.SchemaVersionMismatchError(second);
+        }
+        throw first;
+    }
     return reply.length === 1 ? {
         headers: undefined,
         data: undefined,

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

@@ -2,6 +2,6 @@ import { RedisArgument, CommandParser } from '@redis/client';
 import { QueryOptionsBackwardCompatible } from '.';
 export { FIRST_KEY_INDEX } from './QUERY';
 export declare const IS_READ_ONLY = true;
-export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): void;
-export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): Array<RedisArgument>;
+export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): void;
+export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): Array<RedisArgument>;
 export { transformReply } from './QUERY';

package/dist/src/commands/RO_QUERY.js

@@ -7,12 +7,12 @@ const _1 = require(".");
 var QUERY_1 = require("./QUERY");
 Object.defineProperty(exports, "FIRST_KEY_INDEX", { enumerable: true, get: function () { return QUERY_1.FIRST_KEY_INDEX; } });
 exports.IS_READ_ONLY = true;
-function parseCommand(parser, graph, query, options, compact) {
-    const args = (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact);
+function parseCommand(parser, graph, query, options, compact, version) {
+    const args = (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact, version);
     parser.push(...args);
 }
-function transformArguments(graph, query, options, compact) {
-    return (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact);
+function transformArguments(graph, query, options, compact, version) {
+    return (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact, version);
 }
 var QUERY_2 = require("./QUERY");
 Object.defineProperty(exports, "transformReply", { enumerable: true, get: function () { return QUERY_2.transformReply; } });

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

@@ -1,19 +1,7 @@
 import { CommandParser } from '@redis/client';
+import type { SlowLogRawReply, SlowLogReply } from '../types';
 export declare const IS_READ_ONLY = true;
 export declare const FIRST_KEY_INDEX = 1;
 export declare function parseCommand(parser: CommandParser, key: string): void;
 export declare function transformArguments(key: string): string[];
-type SlowLogRawReply = Array<[
-    timestamp: string,
-    command: string,
-    query: string,
-    took: string
-]>;
-type SlowLogReply = Array<{
-    timestamp: Date;
-    command: string;
-    query: string;
-    took: number;
-}>;
 export declare function transformReply(logs: SlowLogRawReply): SlowLogReply;
-export {};

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

@@ -1,7 +1,7 @@
 import { CommandParser } from '@redis/client';
 export declare const IS_READ_ONLY = true;
-export type UdfLibraryEntry = [string, string[]] | [string, string[], string];
-export type UdfListReply = UdfLibraryEntry[];
+import type { UdfListReply } from '../types';
+export type { UdfLibraryEntry, UdfListReply } from '../types';
 export declare function parseCommand(parser: CommandParser, lib?: string, withCode?: boolean): void;
 export declare function transformArguments(lib?: string, withCode?: boolean): Array<string>;
 export declare function transformReply(reply: unknown): UdfListReply;

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

@@ -20,6 +20,7 @@ import * as UDF_LIST from './UDF_LIST';
 import * as UDF_FLUSH from './UDF_FLUSH';
 import * as UDF_DELETE from './UDF_DELETE';
 import { RedisArgument } from '@redis/client';
+import type { QueryOptionsBackwardCompatible } from '../types';
 declare const _default: {
     CONFIG_GET: typeof CONFIG_GET;
     configGet: typeof CONFIG_GET;
@@ -65,14 +66,6 @@ declare const _default: {
     udfDelete: typeof UDF_DELETE;
 };
 export default _default;
-type QueryParam = null | string | number | boolean | QueryParams | Array<QueryParam>;
-type QueryParams = {
-    [key: string]: QueryParam;
-};
-export interface QueryOptions {
-    params?: QueryParams;
-    TIMEOUT?: number;
-}
-export type QueryOptionsBackwardCompatible = QueryOptions | number;
-export declare function pushQueryArguments(args: Array<RedisArgument>, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): Array<RedisArgument>;
-export type { UdfListReply, UdfLibraryEntry } from './UDF_LIST';
+export type { QueryOptions, QueryOptionsBackwardCompatible, QueryParam, QueryParams } from '../types';
+export declare function pushQueryArguments(args: Array<RedisArgument>, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): Array<RedisArgument>;
+export type { UdfListReply, UdfLibraryEntry } from '../types';

package/dist/src/commands/index.js

@@ -1,27 +1,60 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pushQueryArguments = pushQueryArguments;
-const CONFIG_GET = require("./CONFIG_GET");
-const CONFIG_SET = require("./CONFIG_SET");
-const DELETE = require("./DELETE");
-const EXPLAIN = require("./EXPLAIN");
-const INFO = require("./INFO");
-const LIST = require("./LIST");
-const PROFILE = require("./PROFILE");
-const QUERY = require("./QUERY");
-const RO_QUERY = require("./RO_QUERY");
-const SLOWLOG = require("./SLOWLOG");
-const STUBS = require("./STUBS");
-const CONSTRAINT_CREATE = require("./CONSTRAINT_CREATE");
-const CONSTRAINT_DROP = require("./CONSTRAINT_DROP");
-const COPY = require("./COPY");
-const SENTINEL_MASTER = require("./SENTINEL_MASTER");
-const SENTINEL_MASTERS = require("./SENTINEL_MASTERS");
-const MEMORY_USAGE = require("./MEMORY_USAGE");
-const UDF_LOAD = require("./UDF_LOAD");
-const UDF_LIST = require("./UDF_LIST");
-const UDF_FLUSH = require("./UDF_FLUSH");
-const UDF_DELETE = require("./UDF_DELETE");
+const CONFIG_GET = __importStar(require("./CONFIG_GET"));
+const CONFIG_SET = __importStar(require("./CONFIG_SET"));
+const DELETE = __importStar(require("./DELETE"));
+const EXPLAIN = __importStar(require("./EXPLAIN"));
+const INFO = __importStar(require("./INFO"));
+const LIST = __importStar(require("./LIST"));
+const PROFILE = __importStar(require("./PROFILE"));
+const QUERY = __importStar(require("./QUERY"));
+const RO_QUERY = __importStar(require("./RO_QUERY"));
+const SLOWLOG = __importStar(require("./SLOWLOG"));
+const STUBS = __importStar(require("./STUBS"));
+const CONSTRAINT_CREATE = __importStar(require("./CONSTRAINT_CREATE"));
+const CONSTRAINT_DROP = __importStar(require("./CONSTRAINT_DROP"));
+const COPY = __importStar(require("./COPY"));
+const SENTINEL_MASTER = __importStar(require("./SENTINEL_MASTER"));
+const SENTINEL_MASTERS = __importStar(require("./SENTINEL_MASTERS"));
+const MEMORY_USAGE = __importStar(require("./MEMORY_USAGE"));
+const UDF_LOAD = __importStar(require("./UDF_LOAD"));
+const UDF_LIST = __importStar(require("./UDF_LIST"));
+const UDF_FLUSH = __importStar(require("./UDF_FLUSH"));
+const UDF_DELETE = __importStar(require("./UDF_DELETE"));
 exports.default = {
     CONFIG_GET,
     configGet: CONFIG_GET,
@@ -66,7 +99,7 @@ exports.default = {
     UDF_DELETE,
     udfDelete: UDF_DELETE,
 };
-function pushQueryArguments(args, graph, query, options, compact) {
+function pushQueryArguments(args, graph, query, options, compact, version) {
     args.push(graph);
     if (typeof options === 'number') {
         args.push(query);
@@ -80,6 +113,9 @@ function pushQueryArguments(args, graph, query, options, compact) {
             pushTimeout(args, options.TIMEOUT);
         }
     }
+    if (version !== undefined) {
+        args.push('version', version.toString());
+    }
     if (compact) {
         args.push('--compact');
     }

package/dist/src/enums/constraint-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum ConstraintType {
+    MANDATORY = "MANDATORY",
+    UNIQUE = "UNIQUE"
+}

package/dist/src/enums/constraint-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstraintType = void 0;
+var ConstraintType;
+(function (ConstraintType) {
+    ConstraintType["MANDATORY"] = "MANDATORY";
+    ConstraintType["UNIQUE"] = "UNIQUE";
+})(ConstraintType || (exports.ConstraintType = ConstraintType = {}));

package/dist/src/enums/entity-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum EntityType {
+    NODE = "NODE",
+    RELATIONSHIP = "RELATIONSHIP"
+}

package/dist/src/enums/entity-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityType = void 0;
+var EntityType;
+(function (EntityType) {
+    EntityType["NODE"] = "NODE";
+    EntityType["RELATIONSHIP"] = "RELATIONSHIP";
+})(EntityType || (exports.EntityType = EntityType = {}));

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

@@ -0,0 +1,19 @@
+export declare enum GraphValueTypes {
+    UNKNOWN = 0,
+    NULL = 1,
+    STRING = 2,
+    INTEGER = 3,
+    BOOLEAN = 4,
+    DOUBLE = 5,
+    ARRAY = 6,
+    EDGE = 7,
+    NODE = 8,
+    PATH = 9,
+    MAP = 10,
+    POINT = 11,
+    VECTORF32 = 12,
+    DATETIME = 13,
+    DATE = 14,
+    TIME = 15,
+    DURATION = 16
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphValueTypes = void 0;
+// 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 || (exports.GraphValueTypes = GraphValueTypes = {}));

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

@@ -0,0 +1,3 @@
+export * from './constraint-type';
+export * from './entity-type';
+export * from './graph-value-types';

package/dist/src/enums/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constraint-type"), exports);
+__exportStar(require("./entity-type"), exports);
+__exportStar(require("./graph-value-types"), exports);

package/dist/src/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The server rejected a query because the graph's schema (its labels,
+ * relationship types and property keys) no longer matches the version the
+ * client sent with it. The query was not executed.
+ */
+export declare class SchemaVersionMismatchError extends Error {
+    /** The graph's current schema version. */
+    readonly version: number;
+    constructor(version: number);
+}

package/dist/src/errors.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaVersionMismatchError = void 0;
+/**
+ * The server rejected a query because the graph's schema (its labels,
+ * relationship types and property keys) no longer matches the version the
+ * client sent with it. The query was not executed.
+ */
+class SchemaVersionMismatchError extends Error {
+    /** The graph's current schema version. */
+    version;
+    constructor(version) {
+        super('version mismatch');
+        this.name = 'SchemaVersionMismatchError';
+        this.version = version;
+    }
+}
+exports.SchemaVersionMismatchError = SchemaVersionMismatchError;