@bardioc/app-sdk 0.5.0 → 1.0.1

package/dist/transports/backend-transport.js

@@ -1,54 +0,0 @@
-import { ValidationError } from '../errors.js';
-import { parseOsError } from './os-transport.js';
-const RELAY_BASE = '/relay';
-// Mirrors the BFF's route key rule: one path segment, "." and ".." excluded.
-const ROUTE_KEY_PATTERN = /^[A-Za-z0-9._-]+$/;
-export function isRouteKey(routeKey) {
-    return routeKey !== '.' && routeKey !== '..' && ROUTE_KEY_PATTERN.test(routeKey);
-}
-/**
- * Client for an application's own REST backend, reached through the BFF relay at
- * `/relay/{routeKey}`. The host stamps the calling app id and scope; the BFF checks the
- * app against the route's whitelist and forwards the request with an app-scoped token.
- */
-export class BackendTransport {
-    _request;
-    routeKey;
-    constructor(_request, routeKey) {
-        this._request = _request;
-        this.routeKey = routeKey;
-        if (!isRouteKey(routeKey)) {
-            throw new ValidationError(`Invalid relay route key: "${routeKey}"`, 'routeKey');
-        }
-    }
-    /**
-     * Send a request to the backend. `path` is what the backend sees, after the relay
-     * stripped `/relay/{routeKey}`. Scope is required unless stated otherwise: the relay
-     * refuses an app-scoped call without one.
-     *
-     * @throws {EntityNotFoundError} on 404 errors
-     * @throws {ValidationError} on 400 errors
-     * @throws {PermissionError} on 403 errors (app not whitelisted for the route)
-     * @throws {NetworkError} on HTTP errors, including 502 when the backend is unreachable
-     * @throws {TimeoutError} on request timeout
-     */
-    async request(options) {
-        const path = options.path.startsWith('/') ? options.path : `/${options.path}`;
-        try {
-            return await this._request({
-                path: `${RELAY_BASE}/${this.routeKey}${path}`,
-                method: options.method || 'GET',
-                body: options.body,
-                contentType: options.contentType,
-                scopeId: options.scopeId,
-                scopePolicy: options.scopePolicy ?? 'required',
-            });
-        }
-        catch (error) {
-            throw parseOsError(error, `backend.${this.routeKey}.request`, {
-                path: options.path,
-                method: options.method,
-            });
-        }
-    }
-}

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

@@ -1,241 +0,0 @@
-import type { BatchResult, CombinedQueryOptions, DeleteOptions, GetNodeOptions, GraphEdgeRaw, GraphNodeRaw, GremlinOptions, HistoryEntry, HistoryOptions, MutationOptions, QueryOptions, SdkTransportPayload, TimeseriesHistory, TimeseriesHistoryOptions, 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: Elasticsearch selects the start vertices, the Gremlin traversal
-     * runs from their IDs. Returns raw results (structure varies by the traversal).
-     *
-     * The result is one flat set for all start vertices — it carries no marker for which start
-     * vertex a row came from. Label and select in the traversal when attribution is needed.
-     *
-     * @example
-     * const speeches = await graph.combined(
-     *   '+(ogit\\/_type: "ogit/Politics/AgendaItem")',
-     *   "inE().outV().has('ogit/_type', 'ogit/Politics/Discussion')",
-     *   { limit: 1000 }
-     * );
-     *
-     * @throws {ValidationError} if either query is invalid
-     * @throws {NetworkError} on HTTP errors
-     * @throws {TimeoutError} on request timeout
-     */
-    combined<T = unknown>(elasticsearchQuery: string, gremlinQuery: string, options?: CombinedQueryOptions): 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.
-         *
-         * `withIds` pulls further time series into the same request and `aggregate` combines the
-         * values sharing a timestamp. Entries carry only timestamp and value, so a multi-ID request
-         * yields one merged series — read a single ID per request when values must stay attributable.
-         *
-         * @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[]>;
-        /**
-         * Get every value ever written for one timestamp of a time series.
-         * Keyed by timestamp, so a single-timestamp request returns a single-entry map.
-         *
-         * @throws {EntityNotFoundError} if time series doesn't exist
-         * @throws {NetworkError} on HTTP errors
-         * @throws {TimeoutError} on request timeout
-         */
-        history: (id: string, timestamp: number, options?: TimeseriesHistoryOptions) => Promise<TimeseriesHistory>;
-    };
-    /**
-     * 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>;
-    };
-}