@bardioc/app-sdk 0.4.0

package/dist/transports/graph-transport.d.ts

@@ -0,0 +1,224 @@
+import type { BatchResult, DeleteOptions, GetNodeOptions, GraphEdgeRaw, GraphNodeRaw, GremlinOptions, HistoryEntry, HistoryOptions, MutationOptions, QueryOptions, SdkTransportPayload, TimeseriesOptions, TimeseriesQueryOptions, TimeseriesValue, TransportScopeOptions } from '../types.js';
+/** Graph transport class providing graph database operations */
+export declare class GraphTransport {
+    private _request;
+    private _debug;
+    constructor(_request: <T = unknown>(payload: SdkTransportPayload) => Promise<T>, options?: {
+        debug?: boolean;
+    });
+    private log;
+    private withScope;
+    /**
+     * Get single node by ID
+     * Returns raw backend format (ogit/* fields)
+     *
+     * @throws {EntityNotFoundError} if node doesn't exist
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    get<T = GraphNodeRaw>(id: string, options?: GetNodeOptions): Promise<T>;
+    /**
+     * Get multiple nodes by IDs (batched request)
+     * Uses /query/ids endpoint
+     *
+     * @returns Array in same order as input IDs (missing nodes = undefined)
+     * @throws {ValidationError} if ids array is empty or invalid
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    getMany<T = GraphNodeRaw>(ids: string[], options?: GetNodeOptions): Promise<(T | undefined)[]>;
+    /**
+     * Get node by external ID
+     *
+     * @throws {EntityNotFoundError} if XID doesn't exist
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    getByXid<T = GraphNodeRaw>(xid: string, options?: GetNodeOptions): Promise<T>;
+    /**
+     * Query nodes using Lucene syntax
+     * Returns raw backend format (ogit/* fields)
+     *
+     * @example
+     * const people = await graph.query<GraphNodeRaw>(
+     *   'ogit/_type:ogit/Person',
+     *   { limit: 50, offset: 0 }
+     * );
+     *
+     * @throws {ValidationError} if query syntax is invalid
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    query<T = GraphNodeRaw>(lucene: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Execute Gremlin traversal query
+     * Returns raw results (structure varies by query)
+     *
+     * @example
+     * const edges = await graph.gremlin(rootId, "outE('ogit/relates')");
+     *
+     * @throws {EntityNotFoundError} if root node doesn't exist
+     * @throws {ValidationError} if query syntax is invalid
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    gremlin<T = unknown>(rootId: string, query: string, options?: GremlinOptions): Promise<T[]>;
+    /**
+     * Execute combined query (Lucene + Gremlin in single call)
+     * Returns raw results (structure varies by query)
+     *
+     * @example
+     * const results = await graph.combined(
+     *   'ogit/_type:ogit/Person AND name:Test',
+     *   { limit: 50 }
+     * );
+     *
+     * @throws {ValidationError} if query syntax is invalid
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    combined<T = unknown>(query: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Create new graph node
+     *
+     * @param type - OGIT type (e.g., 'ogit/Person')
+     * @param data - Node attributes (ogit/* format)
+     * @returns Created node (raw backend format)
+     *
+     * @throws {ValidationError} if data is invalid or missing required fields
+     * @throws {PermissionError} if user lacks permission to create this type
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    create<T = GraphNodeRaw>(type: string, data: Record<string, unknown>, options?: MutationOptions): Promise<T>;
+    /**
+     * Update existing node
+     *
+     * @param id - Node ID
+     * @param data - Fields to update (ogit/* format)
+     * @returns Updated node (raw backend format)
+     *
+     * @throws {EntityNotFoundError} if node doesn't exist
+     * @throws {ValidationError} if data is invalid
+     * @throws {PermissionError} if user lacks permission to update this node
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    update<T = GraphNodeRaw>(id: string, data: Record<string, unknown>, options?: MutationOptions): Promise<T>;
+    /**
+     * Delete node (soft delete by default)
+     *
+     * @throws {EntityNotFoundError} if node doesn't exist
+     * @throws {PermissionError} if user lacks permission to delete this node
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    delete(id: string, options?: DeleteOptions): Promise<void>;
+    /**
+     * Create edge between two nodes
+     *
+     * @param from - Source node ID
+     * @param to - Target node ID
+     * @param type - Edge type (e.g., 'ogit/relates')
+     * @returns Created edge (raw backend format)
+     *
+     * @throws {EntityNotFoundError} if either node doesn't exist
+     * @throws {ValidationError} if edge type is invalid or not allowed
+     * @throws {PermissionError} if user lacks permission to create this edge
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    connect<T = GraphEdgeRaw>(from: string, to: string, type: string, options?: MutationOptions): Promise<T>;
+    /**
+     * Get node history
+     *
+     * @param nodeId - Node ID
+     * @param options - Time range, limit, etc.
+     * @returns Array of historical versions
+     *
+     * @throws {EntityNotFoundError} if node doesn't exist
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    history(nodeId: string, options?: HistoryOptions): Promise<HistoryEntry[]>;
+    /**
+     * Batch operations
+     */
+    batch: {
+        /**
+         * Delete multiple nodes in parallel
+         * Continues deleting even if some fail
+         *
+         * @param ids - Array of node IDs to delete
+         * @param options - Delete options (hard delete, etc.)
+         * @returns BatchResult with succeeded and failed IDs
+         *
+         * @example
+         * const result = await graph.batch.delete(['id1', 'id2', 'id3'], { hard: false });
+         * console.log(`Deleted: ${result.succeeded.length}, Failed: ${result.failed.length}`);
+         * result.failed.forEach(f => console.error(`Failed ${f.id}: ${f.error}`));
+         */
+        delete: (ids: string[], options?: DeleteOptions) => Promise<BatchResult>;
+    };
+    /**
+     * Time series operations
+     */
+    timeseries: {
+        /**
+         * Get time series values
+         *
+         * @throws {EntityNotFoundError} if time series doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        get: (id: string, options?: TimeseriesOptions) => Promise<TimeseriesValue[]>;
+        /**
+         * Add time series values
+         *
+         * @throws {EntityNotFoundError} if time series doesn't exist
+         * @throws {ValidationError} if values format is invalid
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        add: (id: string, values: TimeseriesValue[], options?: TransportScopeOptions) => Promise<void>;
+        /**
+         * Query time series with filters
+         *
+         * @throws {ValidationError} if query options are invalid
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        query: (options: TimeseriesQueryOptions) => Promise<TimeseriesValue[]>;
+    };
+    /**
+     * Content/blob operations
+     */
+    content: {
+        /**
+         * Upload binary content to a node
+         *
+         * @param nodeId - Node ID to attach content to
+         * @param data - Binary content as Blob
+         * @param contentType - MIME type (e.g., 'image/png', 'application/pdf')
+         * @returns Content ID for later retrieval
+         *
+         * @throws {EntityNotFoundError} if node doesn't exist
+         * @throws {ValidationError} if content is invalid
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        set: (nodeId: string, data: Blob, contentType: string, options?: TransportScopeOptions) => Promise<string>;
+        /**
+         * Download binary content from a node
+         *
+         * @param nodeId - Node ID
+         * @param contentId - Content ID returned from set operation
+         * @returns Binary content as Blob
+         *
+         * @throws {EntityNotFoundError} if node or content doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        get: (nodeId: string, contentId: string, options?: TransportScopeOptions) => Promise<Blob>;
+    };
+}