rice-node-sdk 1.0.0

package/dist/storage/client/GrpcClient.js

@@ -0,0 +1,398 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcClient = void 0;
+const grpc_js_1 = require("@grpc/grpc-js");
+const BaseClient_1 = require("./BaseClient");
+const ricedb_1 = require("../proto/ricedb");
+const long_1 = __importDefault(require("long"));
+const BitVector_1 = require("../utils/BitVector");
+class GrpcClient extends BaseClient_1.BaseRiceDBClient {
+    constructor(host = "localhost", port = 50051, token) {
+        super(host, port);
+        this.client = null;
+        this.token = null;
+        if (token) {
+            this.token = token;
+        }
+    }
+    async connect() {
+        const address = `${this.host}:${this.port}`;
+        this.client = new ricedb_1.RiceDBClient(address, grpc_js_1.credentials.createInsecure(), {
+            "grpc.max_send_message_length": 50 * 1024 * 1024,
+            "grpc.max_receive_message_length": 50 * 1024 * 1024,
+        });
+        try {
+            await this.health();
+            this.connected = true;
+            return true;
+        }
+        catch (e) {
+            this.connected = false;
+            throw e;
+        }
+    }
+    disconnect() {
+        if (this.client) {
+            this.client.close();
+            this.client = null;
+        }
+        this.connected = false;
+    }
+    getMetadata() {
+        const metadata = new grpc_js_1.Metadata();
+        if (this.token) {
+            metadata.add("authorization", `Bearer ${this.token}`);
+        }
+        return metadata;
+    }
+    promisify(method, req) {
+        return new Promise((resolve, reject) => {
+            if (!this.client)
+                return reject(new Error("Not connected"));
+            method.call(this.client, req, this.getMetadata(), (err, res) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(res);
+            });
+        });
+    }
+    async health() {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.health, {});
+        return res;
+    }
+    async login(username, password) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.login, { username, password });
+        this.token = res.token;
+        return this.token;
+    }
+    async createUser(username, password, role = "user") {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.createUser, {
+            username,
+            password,
+            role,
+        });
+        return res.userId;
+    }
+    async deleteUser(username) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.deleteUser, { username });
+        return res.success;
+    }
+    async getUser(username) {
+        throw new Error("Get user is not supported via gRPC transport. Use HTTP.");
+    }
+    async listUsers() {
+        throw new Error("List users is not supported via gRPC transport. Use HTTP.");
+    }
+    async insert(nodeId, text, metadata, userId = 1, sessionId, embedding) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = {
+            id: this.toLong(nodeId),
+            text,
+            metadata: Buffer.from(JSON.stringify(metadata)),
+            userId: this.toLong(userId),
+            sessionId,
+            embedding: embedding || [],
+        };
+        const res = await this.promisify(this.client.insert, req);
+        return res;
+    }
+    async search(query, userId, k = 10, sessionId, filter, queryEmbedding) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = {
+            queryText: query,
+            userId: this.toLong(userId),
+            k,
+            sessionId,
+            filter: filter ? JSON.stringify(filter) : "",
+            queryEmbedding: queryEmbedding || [],
+        };
+        const res = await this.promisify(this.client.search, req);
+        return res.results.map((r) => ({
+            id: r.id,
+            similarity: r.similarity,
+            metadata: JSON.parse(r.metadata.toString()),
+        }));
+    }
+    async delete(nodeId, sessionId) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.deleteNode, {
+            nodeId: this.toLong(nodeId),
+            sessionId,
+        });
+        return res.success;
+    }
+    async createSession(parentSessionId) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.createSession, {
+            parentSessionId,
+        });
+        return res.sessionId;
+    }
+    async snapshotSession(sessionId, path) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.snapshotSession, {
+            sessionId,
+            path,
+        });
+        return res.success;
+    }
+    async loadSession(path) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.loadSession, { path });
+        return res.sessionId;
+    }
+    async commitSession(sessionId, mergeStrategy = "overwrite") {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.commitSession, {
+            sessionId,
+            mergeStrategy,
+        });
+        return res.success;
+    }
+    async dropSession(sessionId) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.dropSession, {
+            sessionId,
+        });
+        return res.success;
+    }
+    async writeMemory(address, data, userId = 1) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = {
+            address: { chunks: address.toList() },
+            data: { chunks: data.toList() },
+            userId: this.toLong(userId),
+        };
+        const res = await this.promisify(this.client.writeMemory, req);
+        return { success: res.success, message: res.message };
+    }
+    async readMemory(address, userId = 1) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = {
+            address: { chunks: address.toList() },
+            userId: this.toLong(userId),
+        };
+        const res = await this.promisify(this.client.readMemory, req);
+        return new BitVector_1.BitVector(res.data.chunks);
+    }
+    async addMemory(sessionId, agentId, content, metadata = {}, ttlSeconds) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = { sessionId, agentId, content, metadata, ttlSeconds };
+        const res = await this.promisify(this.client.addMemory, req);
+        return { success: res.success, message: res.message, entry: res.entry };
+    }
+    async getMemory(sessionId, limit = 50, after = 0, filter = {}) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = {
+            sessionId,
+            limit,
+            afterTimestamp: long_1.default.fromValue(after),
+            filter,
+        };
+        const res = await this.promisify(this.client.getMemory, req);
+        return res.entries;
+    }
+    async clearMemory(sessionId) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const res = await this.promisify(this.client.clearMemory, {
+            sessionId,
+        });
+        return { success: res.success, message: res.message };
+    }
+    async *watchMemory(sessionId) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const stream = this.client.watchMemory({ sessionId }, this.getMetadata());
+        for await (const event of stream) {
+            yield event;
+        }
+    }
+    async addEdge(fromNode, toNode, relation, weight = 1.0) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = {
+            from: this.toLong(fromNode),
+            to: this.toLong(toNode),
+            relation,
+            weight,
+        };
+        const res = await this.promisify(this.client.addEdge, req);
+        return res.success;
+    }
+    async getNeighbors(nodeId, relation) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = { nodeId: this.toLong(nodeId), relation };
+        const res = await this.promisify(this.client.getNeighbors, req);
+        return res.neighbors;
+    }
+    async traverse(startNode, maxDepth = 1) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = { start: this.toLong(startNode), maxDepth };
+        const res = await this.promisify(this.client.traverseGraph, req);
+        return res.visited;
+    }
+    async sampleGraph(limit = 100) {
+        throw new Error("Sample graph is not supported via gRPC transport. Use HTTP.");
+    }
+    async *subscribe(filterType = "all", nodeId, queryText = "", threshold = 0.8) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = {
+            filterType,
+            nodeId: nodeId ? this.toLong(nodeId) : undefined,
+            vector: [],
+            queryText,
+            threshold,
+        };
+        const stream = this.client.subscribe(req, this.getMetadata());
+        for await (const event of stream) {
+            const res = { type: event.type, nodeId: event.nodeId };
+            if (event.node) {
+                res.node = {
+                    id: event.node.id,
+                    metadata: JSON.parse(event.node.metadata.toString()),
+                };
+            }
+            yield res;
+        }
+    }
+    async batchInsert(documents, userId = 1) {
+        if (!this.client)
+            throw new Error("Not connected");
+        return new Promise((resolve, reject) => {
+            if (!this.client)
+                return reject(new Error("Not connected"));
+            const stream = this.client.batchInsert(this.getMetadata(), (err, res) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve({ count: res.count, nodeIds: res.nodeIds });
+            });
+            for (const doc of documents) {
+                const docUserId = doc.userId !== undefined
+                    ? this.toLong(doc.userId)
+                    : this.toLong(userId);
+                const text = doc.text || "";
+                const metadata = Buffer.from(JSON.stringify(doc.metadata));
+                stream.write({
+                    id: this.toLong(doc.id),
+                    text,
+                    metadata,
+                    userId: docUserId,
+                    sessionId: undefined,
+                });
+            }
+            stream.end();
+        });
+    }
+    async grantPermission(nodeId, userId, permissions) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = {
+            nodeId: this.toLong(nodeId),
+            targetUserId: this.toLong(userId),
+            permissions: {
+                read: permissions.read || false,
+                write: permissions.write || false,
+                delete: permissions.delete || false,
+            },
+        };
+        const res = await this.promisify(this.client.grantPermission, req);
+        return res.success;
+    }
+    async revokePermission(nodeId, userId) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const req = {
+            nodeId: this.toLong(nodeId),
+            targetUserId: this.toLong(userId),
+        };
+        const res = await this.promisify(this.client.revokePermission, req);
+        return res.success;
+    }
+    async checkPermission(nodeId, userId, permissionType) {
+        console.warn(`checkPermission not supported via gRPC, assuming false for ${nodeId}`);
+        return false;
+    }
+    async batchGrant(grants) {
+        const results = [];
+        const errors = [];
+        for (let i = 0; i < grants.length; i++) {
+            const grant = grants[i];
+            try {
+                const success = await this.grantPermission(grant.nodeId, grant.userId, grant.permissions);
+                results.push({
+                    index: i,
+                    nodeId: grant.nodeId,
+                    userId: grant.userId,
+                    success: true,
+                    result: success,
+                });
+            }
+            catch (e) {
+                errors.push({
+                    index: i,
+                    nodeId: grant.nodeId,
+                    userId: grant.userId,
+                    error: e.message || String(e),
+                });
+            }
+        }
+        return {
+            total: grants.length,
+            successful: results.length,
+            failed: errors.length,
+            results,
+            errors,
+        };
+    }
+    async insertWithAcl(nodeId, text, metadata, userPermissions) {
+        if (!userPermissions || userPermissions.length === 0) {
+            throw new Error("At least one user permission must be provided");
+        }
+        const primaryUser = userPermissions[0];
+        const primaryUserId = primaryUser.userId;
+        // 1. Insert for primary user
+        const insertRes = await this.insert(nodeId, text, metadata, primaryUserId);
+        // 2. Grant permissions for others
+        const additionalGrants = userPermissions.slice(1).map((p) => ({
+            nodeId: nodeId,
+            userId: p.userId,
+            permissions: p.permissions,
+        }));
+        if (additionalGrants.length > 0) {
+            const grantRes = await this.batchGrant(additionalGrants);
+            insertRes.aclGrants = grantRes;
+        }
+        insertRes.aclUsers = userPermissions;
+        return insertRes;
+    }
+}
+exports.GrpcClient = GrpcClient;

package/dist/storage/client/HttpClient.d.ts

@@ -0,0 +1,87 @@
+import { BaseRiceDBClient, HealthInfo, InsertResult, SearchResultItem, MemoryEntry } from "./BaseClient";
+import Long from "long";
+import { BitVector } from "../utils/BitVector";
+export declare class HttpClient extends BaseRiceDBClient {
+    private client;
+    private token;
+    constructor(host?: string, port?: number, token?: string);
+    connect(): Promise<boolean>;
+    disconnect(): void;
+    private setAuthHeader;
+    private request;
+    health(): Promise<HealthInfo>;
+    login(username: string, password: string): Promise<string>;
+    createUser(username: string, password: string, role?: string): Promise<Long>;
+    deleteUser(username: string): Promise<boolean>;
+    getUser(username: string): Promise<any>;
+    listUsers(): Promise<any[]>;
+    insert(nodeId: Long | number | string, text: string, metadata: any, userId?: Long | number | string, sessionId?: string, embedding?: number[]): Promise<InsertResult>;
+    search(query: string, userId: Long | number | string, k?: number, sessionId?: string, filter?: {
+        [key: string]: any;
+    }, queryEmbedding?: number[]): Promise<SearchResultItem[]>;
+    delete(nodeId: Long | number | string, sessionId?: string): Promise<boolean>;
+    createSession(parentSessionId?: string): Promise<string>;
+    snapshotSession(sessionId: string, path: string): Promise<boolean>;
+    loadSession(path: string): Promise<string>;
+    commitSession(sessionId: string, mergeStrategy?: string): Promise<boolean>;
+    dropSession(sessionId: string): Promise<boolean>;
+    writeMemory(address: BitVector, data: BitVector, userId?: Long | number | string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    readMemory(address: BitVector, userId?: Long | number | string): Promise<BitVector>;
+    addMemory(sessionId: string, agentId: string, content: string, metadata?: {
+        [key: string]: string;
+    }, ttlSeconds?: number): Promise<{
+        success: boolean;
+        message: string;
+        entry: MemoryEntry;
+    }>;
+    getMemory(sessionId: string, limit?: number, after?: number | Long, filter?: {
+        [key: string]: string;
+    }): Promise<MemoryEntry[]>;
+    clearMemory(sessionId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    watchMemory(sessionId: string): AsyncIterable<any>;
+    addEdge(fromNode: Long | number | string, toNode: Long | number | string, relation: string, weight?: number): Promise<boolean>;
+    getNeighbors(nodeId: Long | number | string, relation?: string): Promise<Long[]>;
+    traverse(startNode: Long | number | string, maxDepth?: number): Promise<Long[]>;
+    sampleGraph(limit?: number): Promise<any>;
+    subscribe(filterType?: string, nodeId?: Long | number | string, queryText?: string, threshold?: number): AsyncIterable<any>;
+    batchInsert(documents: any[], userId?: Long | number | string): Promise<{
+        count: number;
+        nodeIds: Long[];
+    }>;
+    grantPermission(nodeId: Long | number | string, userId: Long | number | string, permissions: {
+        read?: boolean;
+        write?: boolean;
+        delete?: boolean;
+    }): Promise<boolean>;
+    revokePermission(nodeId: Long | number | string, userId: Long | number | string): Promise<boolean>;
+    checkPermission(nodeId: Long | number | string, userId: Long | number | string, permissionType: string): Promise<boolean>;
+    batchGrant(grants: Array<{
+        nodeId: Long | number | string;
+        userId: Long | number | string;
+        permissions: {
+            read?: boolean;
+            write?: boolean;
+            delete?: boolean;
+        };
+    }>): Promise<{
+        total: number;
+        successful: number;
+        failed: number;
+        results: any[];
+        errors: any[];
+    }>;
+    insertWithAcl(nodeId: Long | number | string, text: string, metadata: any, userPermissions: Array<{
+        userId: Long | number | string;
+        permissions: {
+            read?: boolean;
+            write?: boolean;
+            delete?: boolean;
+        };
+    }>): Promise<InsertResult>;
+}