falkordb 6.2.6 → 6.2.7

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Graph } from './src/graph';
+export { ConstraintType, EntityType } from './src/graph';
+export { default as FalkorDB } from './src/falkordb';

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FalkorDB = exports.EntityType = exports.ConstraintType = exports.Graph = void 0;
+var graph_1 = require("./src/graph");
+Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return graph_1.default; } });
+var graph_2 = require("./src/graph");
+Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return graph_2.ConstraintType; } });
+Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return graph_2.EntityType; } });
+var falkordb_1 = require("./src/falkordb");
+Object.defineProperty(exports, "FalkorDB", { enumerable: true, get: function () { return falkordb_1.default; } });

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

@@ -0,0 +1,32 @@
+import { RedisCommandArgument } from "@redis/client/dist/lib/commands";
+import { QueryOptions } from "../commands";
+import { ConstraintType, EntityType } from "../graph";
+import FalkorDB from "../falkordb";
+import { SingleGraphConnection } from "./single";
+export interface Client {
+    init(falkordb: FalkorDB): Promise<void>;
+    list(): Promise<Array<string>>;
+    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: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<any>;
+    profile<T>(graph: string, query: RedisCommandArgument): Promise<any>;
+    roQuery<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<any>;
+    copy<T>(srcGraph: string, destGraph: string): Promise<any>;
+    delete(graph: string): Promise<void>;
+    explain(graph: string, query: string): Promise<any>;
+    slowLog(graph: string): Promise<{
+        timestamp: Date;
+        command: string;
+        query: string;
+        took: number;
+    }[]>;
+    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>;
+    /**
+     * @deprecated Use `disconnect` instead
+     */
+    quit(): Promise<void>;
+    disconnect(): Promise<void>;
+    getConnection(): Promise<SingleGraphConnection>;
+}

package/dist/src/clients/client.js

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

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

@@ -0,0 +1,57 @@
+import { Client } from "./client";
+import { ConstraintType, EntityType } from "../graph";
+import { RedisCommandArgument, RedisFunctions, RedisScripts } from "@redis/client/dist/lib/commands";
+import commands, { QueryOptions } from "../commands";
+import { RedisClusterType } from "@redis/client";
+import FalkorDB from "../falkordb";
+import { SingleGraphConnection } from "./single";
+export type ClusterGraphConnection = RedisClusterType<{
+    falkordb: typeof commands;
+}, RedisFunctions, RedisScripts>;
+/**
+ * A client that connects to a Redis Cluster.
+ */
+export declare class Cluster implements Client {
+    #private;
+    constructor(client: SingleGraphConnection);
+    getConnection(): Promise<import("@redis/client").RedisClientType<{
+        falkordb: typeof commands;
+    }, RedisFunctions, RedisScripts>>;
+    init(falkordb: FalkorDB): Promise<void>;
+    query<T>(graph: string, query: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<{
+        headers: undefined;
+        data: undefined;
+        metadata: string[];
+    } | {
+        headers: string[];
+        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: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<{
+        headers: undefined;
+        data: undefined;
+        metadata: string[];
+    } | {
+        headers: string[];
+        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[];
+    }>;
+    delete(graph: string): Promise<void>;
+    explain(graph: string, query: string): Promise<string | number | (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 | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined>;
+    list(): Promise<Array<string>>;
+    configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
+    configSet(configKey: string, value: number | string): Promise<void>;
+    info(section?: string): Promise<(string | string[])[]>;
+    copy<_T>(srcGraph: string, destGraph: string): Promise<"OK">;
+    slowLog(graph: string): Promise<{
+        timestamp: Date;
+        command: string;
+        query: string;
+        took: number;
+    }[]>;
+    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>;
+    profile<_T>(graph: string, query: string): Promise<string | number | (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 | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined>;
+    quit(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/src/clients/cluster.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cluster = void 0;
+const client_1 = require("@redis/client");
+const lodash = require("lodash");
+/**
+ * A client that connects to a Redis Cluster.
+ */
+class Cluster {
+    #client;
+    constructor(client) {
+        // Convert the single client options to a cluster client options
+        const redisClusterOption = client.options;
+        redisClusterOption.rootNodes = [
+            client.options,
+        ];
+        // Remove the URL from the defaults so it won't override the dynamic cluster URLs
+        const defaults = lodash.cloneDeep(client.options);
+        defaults?.url && delete defaults.url;
+        redisClusterOption.defaults = defaults;
+        redisClusterOption.maxCommandRedirections = 100000;
+        client.disconnect();
+        this.#client = (0, client_1.createCluster)(redisClusterOption);
+    }
+    async getConnection() {
+        const connection = this.#client.nodeClient(this.#client.getRandomNode());
+        return connection instanceof Promise ? await connection : connection;
+    }
+    async init(falkordb) {
+        await this.#client
+            .on("error", (err) => falkordb.emit("error", err)) // Forward errors
+            .connect();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async query(graph, query, options, compact = true) {
+        return this.#client.falkordb.query(graph, query, options, compact);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async roQuery(graph, query, options, compact = true) {
+        return this.#client.falkordb.roQuery(graph, query, options, compact);
+    }
+    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 list() {
+        return this.#client.falkordb.list();
+    }
+    async configGet(configKey) {
+        return this.#client.falkordb.configGet(configKey);
+    }
+    async configSet(configKey, value) {
+        const reply = this.#client.falkordb.configSet(configKey, value);
+        return reply.then(() => { });
+    }
+    async info(section) {
+        return this.#client.falkordb.info(section);
+    }
+    async copy(srcGraph, destGraph) {
+        return this.#client.falkordb.copy(srcGraph, destGraph);
+    }
+    slowLog(graph) {
+        return this.#client.falkordb.slowLog(graph);
+    }
+    async constraintCreate(graph, constraintType, entityType, label, ...properties) {
+        const reply = this.#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);
+        return reply.then(() => { });
+    }
+    async profile(graph, query) {
+        return this.#client.falkordb.profile(graph, query);
+    }
+    async quit() {
+        return this.disconnect();
+    }
+    async disconnect() {
+        const reply = this.#client.disconnect();
+        return reply.then(() => { });
+    }
+}
+exports.Cluster = Cluster;

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

@@ -0,0 +1,41 @@
+import { RedisCommandArgument } from "@redis/client/dist/lib/commands";
+import { QueryOptions } from "../commands";
+import FalkorDB from "../falkordb";
+import { ConstraintType, EntityType } from "../graph";
+import { Client } from "./client";
+import { SingleGraphConnection } from "./single";
+/**
+ * The `NullClient` class is a placeholder implementation of the `Client` interface.
+ *
+ * This class is designed to be used in scenarios where a client is required, but no actual
+ * implementation is available. All methods in this class throw a "Method not implemented."
+ * error, indicating that the functionality has not been provided.
+ *
+ * The `NullClient` can serve as a base class or a stub for future implementations, or as a
+ * fallback in cases where a functional client is not needed or cannot be instantiated.
+ *
+ */
+export declare class NullClient implements Client {
+    getConnection(): Promise<SingleGraphConnection>;
+    init(_falkordb: FalkorDB): Promise<void>;
+    list(): Promise<Array<string>>;
+    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: RedisCommandArgument, _options?: QueryOptions): Promise<any>;
+    profile<_T>(_graph: string, _query: RedisCommandArgument): Promise<any>;
+    roQuery<_T>(_graph: string, _query: RedisCommandArgument, _options?: QueryOptions): Promise<any>;
+    copy<_T>(_srcGraph: string, _destGraph: string): Promise<any>;
+    delete(_graph: string): Promise<void>;
+    explain(_graph: string, _query: string): Promise<any>;
+    slowLog(_graph: string): Promise<{
+        timestamp: Date;
+        command: string;
+        query: string;
+        took: number;
+    }[]>;
+    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>;
+    quit(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/src/clients/nullClient.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullClient = void 0;
+/**
+ * The `NullClient` class is a placeholder implementation of the `Client` interface.
+ *
+ * This class is designed to be used in scenarios where a client is required, but no actual
+ * implementation is available. All methods in this class throw a "Method not implemented."
+ * error, indicating that the functionality has not been provided.
+ *
+ * The `NullClient` can serve as a base class or a stub for future implementations, or as a
+ * fallback in cases where a functional client is not needed or cannot be instantiated.
+ *
+ */
+class NullClient {
+    getConnection() {
+        throw new Error("Method not implemented.");
+    }
+    init(_falkordb) {
+        throw new Error("Method not implemented.");
+    }
+    list() {
+        throw new Error("Method not implemented.");
+    }
+    configGet(_configKey) {
+        throw new Error("Method not implemented.");
+    }
+    configSet(_configKey, _value) {
+        throw new Error("Method not implemented.");
+    }
+    info(_section) {
+        throw new Error("Method not implemented.");
+    }
+    query(_graph, _query, _options) {
+        throw new Error("Method not implemented.");
+    }
+    profile(_graph, _query) {
+        throw new Error("Method not implemented.");
+    }
+    roQuery(_graph, _query, _options) {
+        throw new Error("Method not implemented.");
+    }
+    copy(_srcGraph, _destGraph) {
+        throw new Error("Method not implemented.");
+    }
+    delete(_graph) {
+        throw new Error("Method not implemented.");
+    }
+    explain(_graph, _query) {
+        throw new Error("Method not implemented.");
+    }
+    slowLog(_graph) {
+        throw new Error("Method not implemented.");
+    }
+    constraintCreate(_graph, _constraintType, _entityType, _label, ..._properties) {
+        throw new Error("Method not implemented.");
+    }
+    constraintDrop(_graph, _constraintType, _entityType, _label, ..._properties) {
+        throw new Error("Method not implemented.");
+    }
+    quit() {
+        throw new Error("Method not implemented.");
+    }
+    disconnect() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.NullClient = NullClient;

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

@@ -0,0 +1,13 @@
+import { Single } from "./single";
+import FalkorDB from "../falkordb";
+export declare class Sentinel extends Single {
+    private sentinelClient;
+    init(falkordb: FalkorDB): Promise<void>;
+    /**
+     * Connect to the server using the details from sentinel server
+     * Register error event to reconnect on error from the sentinel server
+     */
+    private tryConnectSentinelServer;
+    quit(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/src/clients/sentinel.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sentinel = void 0;
+const single_1 = require("./single");
+const client_1 = require("@redis/client");
+function extractDetails(masters) {
+    const allDetails = [];
+    for (const master of masters) {
+        const details = {};
+        for (let i = 0; i < master.length; i += 2) {
+            details[master[i]] = master[i + 1];
+        }
+        allDetails.push(details);
+    }
+    return allDetails;
+}
+class Sentinel extends single_1.Single {
+    sentinelClient;
+    init(falkordb) {
+        const redisOption = (this.client.options ?? {});
+        return this.tryConnectSentinelServer(this.client, redisOption, falkordb);
+    }
+    /**
+     * Connect to the server using the details from sentinel server
+     * Register error event to reconnect on error from the sentinel server
+     */
+    async tryConnectSentinelServer(client, redisOption, falkordb) {
+        // TODO support multi sentinels
+        const masters = await client.falkordb.sentinelMasters();
+        const details = extractDetails(masters);
+        if (details.length > 1) {
+            throw new Error("Multiple masters are not supported");
+        }
+        // Connect to the server with the details from sentinel
+        const socketOptions = {
+            ...redisOption.socket,
+            host: details[0]["ip"],
+            port: parseInt(details[0]["port"]),
+        };
+        const serverOptions = {
+            ...redisOption,
+            socket: socketOptions,
+        };
+        const realClient = (0, client_1.createClient)(serverOptions);
+        // Save sentinel client to quit on quit()
+        this.sentinelClient = client;
+        // Set original client as sentinel and server client as client
+        this.client = realClient;
+        await realClient
+            .on("error", async (err) => {
+            console.debug("Error on server connection", err);
+            // Disconnect the client to avoid further errors and retries
+            realClient.disconnect();
+            // If error occurs on previous server connection, no need to reconnect
+            if (this.client !== realClient) {
+                return;
+            }
+            try {
+                await this.tryConnectSentinelServer(client, redisOption, falkordb);
+                console.debug("Connected to server");
+            }
+            catch (e) {
+                console.debug("Error on server reconnect", e);
+                // Forward errors if reconnection fails
+                falkordb.emit("error", err);
+            }
+        })
+            .connect();
+    }
+    quit() {
+        return this.disconnect();
+    }
+    async disconnect() {
+        const promises = [super.disconnect()];
+        if (this.sentinelClient) {
+            const reply = this.sentinelClient.disconnect();
+            promises.push(reply.then(() => { }));
+        }
+        return Promise.all(promises).then(() => { });
+    }
+}
+exports.Sentinel = Sentinel;

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

@@ -0,0 +1,52 @@
+import { Client } from "./client";
+import { ConstraintType, EntityType } from "../graph";
+import { RedisCommandArgument, RedisFunctions, RedisScripts } from "@redis/client/dist/lib/commands";
+import commands, { QueryOptions } from "../commands";
+import { RedisClientType } from "@redis/client";
+import FalkorDB from "../falkordb";
+export type SingleGraphConnection = RedisClientType<{
+    falkordb: typeof commands;
+}, RedisFunctions, RedisScripts>;
+export declare class Single implements Client {
+    #private;
+    protected client: SingleGraphConnection;
+    constructor(client: SingleGraphConnection);
+    init(_falkordb: FalkorDB): Promise<void>;
+    query<_T>(graph: string, query: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<{
+        headers: undefined;
+        data: undefined;
+        metadata: string[];
+    } | {
+        headers: string[];
+        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: RedisCommandArgument, options?: QueryOptions, compact?: boolean): Promise<{
+        headers: undefined;
+        data: undefined;
+        metadata: string[];
+    } | {
+        headers: string[];
+        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[];
+    }>;
+    delete(graph: string): Promise<void>;
+    explain(graph: string, query: string): Promise<string | number | (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 | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined>;
+    profile<_T>(graph: string, query: string): Promise<string | number | (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 | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined)[] | null | undefined>;
+    list(): Promise<string[]>;
+    configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
+    configSet(configKey: string, value: number | string): Promise<void>;
+    info(section?: string): Promise<(string | string[])[]>;
+    slowLog(graph: string): Promise<{
+        timestamp: Date;
+        command: string;
+        query: string;
+        took: number;
+    }[]>;
+    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>;
+    copy<_T>(srcGraph: string, destGraph: string): Promise<"OK">;
+    quit(): Promise<void>;
+    disconnect(): Promise<void>;
+    getConnection(): Promise<SingleGraphConnection>;
+}

package/dist/src/clients/single.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Single = void 0;
+class Single {
+    client;
+    #usePool;
+    constructor(client) {
+        this.client = client;
+        this.#usePool = !!this.client.options?.isolationPoolOptions;
+    }
+    init(_falkordb) {
+        return Promise.resolve();
+    }
+    async query(graph, query, options, compact = true) {
+        const reply = this.#usePool
+            ? await this.client.executeIsolated(async (isolatedClient) => {
+                return isolatedClient.falkordb.query(graph, query, options, compact);
+            })
+            : await this.client.falkordb.query(graph, query, options, compact);
+        return reply;
+    }
+    async roQuery(graph, query, options, compact = true) {
+        const reply = this.#usePool
+            ? await this.client.executeIsolated(async (isolatedClient) => {
+                return isolatedClient.falkordb.roQuery(graph, query, options, compact);
+            })
+            : await this.client.falkordb.roQuery(graph, query, options, compact);
+        return reply;
+    }
+    async delete(graph) {
+        if (this.#usePool) {
+            return this.client.executeIsolated(async (isolatedClient) => {
+                const reply = isolatedClient.falkordb.delete(graph);
+                return reply.then(() => { });
+            });
+        }
+        const reply = this.client.falkordb.delete(graph);
+        return reply.then(() => { });
+    }
+    async explain(graph, query) {
+        if (this.#usePool) {
+            return this.client.executeIsolated(async (isolatedClient) => {
+                return isolatedClient.falkordb.explain(graph, query);
+            });
+        }
+        return this.client.falkordb.explain(graph, query);
+    }
+    async profile(graph, query) {
+        if (this.#usePool) {
+            return this.client.executeIsolated(async (isolatedClient) => {
+                return isolatedClient.falkordb.profile(graph, query);
+            });
+        }
+        return this.client.falkordb.profile(graph, query);
+    }
+    async list() {
+        return this.client.falkordb.list();
+    }
+    async configGet(configKey) {
+        return this.client.falkordb.configGet(configKey);
+    }
+    async configSet(configKey, value) {
+        const reply = this.client.falkordb.configSet(configKey, value);
+        return reply.then(() => { });
+    }
+    async info(section) {
+        return this.client.falkordb.info(section);
+    }
+    async slowLog(graph) {
+        if (this.#usePool) {
+            return this.client.executeIsolated(async (isolatedClient) => {
+                return isolatedClient.falkordb.slowLog(graph);
+            });
+        }
+        return this.client.falkordb.slowLog(graph);
+    }
+    async constraintCreate(graph, constraintType, entityType, label, ...properties) {
+        const reply = this.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);
+        return reply.then(() => { });
+    }
+    async copy(srcGraph, destGraph) {
+        return this.client.falkordb.copy(srcGraph, destGraph);
+    }
+    quit() {
+        return this.disconnect();
+    }
+    async disconnect() {
+        const reply = this.client.disconnect();
+        return reply.then(() => { });
+    }
+    async getConnection() {
+        return this.client;
+    }
+}
+exports.Single = Single;

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

@@ -0,0 +1,8 @@
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(configKey: string): Array<string>;
+type ConfigItem = [
+    configKey: string,
+    value: number
+];
+export declare function transformReply(): ConfigItem | Array<ConfigItem>;
+export {};

package/dist/src/commands/CONFIG_GET.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_READ_ONLY = void 0;
+exports.transformArguments = transformArguments;
+exports.IS_READ_ONLY = true;
+function transformArguments(configKey) {
+    return ['GRAPH.CONFIG', 'GET', configKey];
+}

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

@@ -0,0 +1,2 @@
+export declare function transformArguments(configKey: string, value: number | string): Array<string>;
+export declare function transformReply(): 'OK';

package/dist/src/commands/CONFIG_SET.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = transformArguments;
+function transformArguments(configKey, value) {
+    return [
+        'GRAPH.CONFIG',
+        'SET',
+        configKey,
+        typeof value === "string" ? value : value.toString()
+    ];
+}

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

@@ -0,0 +1,10 @@
+export declare enum ConstraintType {
+    MANDATORY = "MANDATORY",
+    UNIQUE = "UNIQUE"
+}
+export declare enum EntityType {
+    NODE = "NODE",
+    RELATIONSHIP = "RELATIONSHIP"
+}
+export declare function transformArguments(key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Array<string>;
+export declare function transformReply(): 'PENDING';

package/dist/src/commands/CONSTRAINT_CREATE.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityType = exports.ConstraintType = void 0;
+exports.transformArguments = transformArguments;
+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 = {}));
+// GRAPH.CONSTRAINT CREATE key constraintType {NODE label | RELATIONSHIP reltype} PROPERTIES propCount prop [prop...]
+function transformArguments(key, constraintType, entityType, label, ...properties) {
+    return [
+        'GRAPH.CONSTRAINT', 'CREATE',
+        key, constraintType, entityType, label,
+        'PROPERTIES', properties.length.toString(), ...properties
+    ];
+}

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

@@ -0,0 +1,3 @@
+import { ConstraintType, EntityType } from "./CONSTRAINT_CREATE";
+export declare function transformArguments(key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Array<string>;
+export declare function transformReply(): 'OK';

package/dist/src/commands/CONSTRAINT_DROP.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = transformArguments;
+// GRAPH.CONSTRAINT DROP key constraintType {NODE label | RELATIONSHIP reltype} PROPERTIES propCount prop [prop...]
+function transformArguments(key, constraintType, entityType, label, ...properties) {
+    return [
+        'GRAPH.CONSTRAINT', 'DROP',
+        key, constraintType, entityType, label,
+        'PROPERTIES', properties.length.toString(), ...properties
+    ];
+}

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

@@ -0,0 +1,2 @@
+export declare function transformArguments(srcGraph: string, destGraph: string): Array<string>;
+export declare function transformReply(): 'OK';