@sovaria/sdk 0.0.0-stage → 0.5.0

package/dist/client.d.ts

@@ -0,0 +1,146 @@
+import type { Bucket, ColumnDefinition, DocumentGetResponse, DocumentPutResponse, DocumentScanResult, FunctionDeployResponse, FunctionInvokeResponse, NodeResponse, RealtimeCallback, RealtimeSubscription, SovariaClientOptions, StorageObject, TimelineJumpResponse, TimelineLogResponse, TokenResponse, UserProfile } from "./types.js";
+/**
+ * Async TypeScript client for the Sovaria API Gateway.
+ *
+ * @deprecated Use {@link SovariaSDK} from `./index`. This legacy client is retained
+ * for in-repo tests only and is not a public package export.
+ *
+ * All requests flow through the gateway; engines are never called directly.
+ * Token refresh is automatic and transparent.
+ *
+ * @example
+ * ```ts
+ * const sov = new SovariaClient("https://api.sovaria.in");
+ * await sov.auth.login("user@example.com", "password"); // deprecated; posts to /console/login
+ * sov.setContext("org-123", "proj-456");
+ *
+ * const rows = await sov.data.sql.query("SELECT * FROM users LIMIT 10");
+ * await sov.auth.logout();
+ * ```
+ */
+export declare class SovariaClient {
+    private readonly baseUrl;
+    private accessToken;
+    private refreshToken;
+    private expiresAt;
+    private orgId;
+    private projectId;
+    private envId;
+    private refreshPromise;
+    private onTokenRefresh?;
+    readonly auth: AuthModule;
+    readonly org: OrgModule;
+    readonly data: DataModule;
+    readonly storage: StorageModule;
+    readonly functions: FunctionsModule;
+    readonly realtime: RealtimeModule;
+    readonly chrono: ChronoModule;
+    constructor(baseUrl: string, options?: SovariaClientOptions);
+    /**
+     * Bind org/project context for multi-tenant headers.
+     * These are injected as `X-Sovaria-Org-ID` and `X-Sovaria-Project-ID`
+     * on every subsequent request.
+     */
+    setContext(orgId: string, projectId: string, envId?: string): void;
+    clearContext(): void;
+    /** @internal */
+    _setTokens(tokens: TokenResponse): void;
+    /** @internal */
+    _clearTokens(): void;
+    /** @internal */
+    get _refreshToken(): string | null;
+    /** @internal */
+    get _isAuthenticated(): boolean;
+    /**
+     * Execute an HTTP request with automatic auth injection, token refresh, and
+     * exponential back-off with jitter on transient failures.
+     *
+     * @internal
+     */
+    _request<T = unknown>(method: string, path: string, options?: {
+        body?: unknown;
+        params?: Record<string, string>;
+        requiresAuth?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    private ensureTokenFresh;
+    private doRefresh;
+    /**
+     * Build a WebSocket URL from the base URL, converting http(s) to ws(s).
+     * @internal
+     */
+    _wsUrl(path: string): string;
+    /** @internal */
+    _issueRealtimeWsTicket(channel: string): Promise<string>;
+    /** @internal */
+    get _accessToken(): string | null;
+}
+declare class AuthModule {
+    private readonly client;
+    constructor(client: SovariaClient);
+    login(email: string, password: string): Promise<TokenResponse>;
+    register(email: string, password: string, name: string): Promise<TokenResponse>;
+    logout(): Promise<void>;
+    me(): Promise<UserProfile>;
+}
+declare class OrgModule {
+    private readonly client;
+    constructor(client: SovariaClient);
+    list(): Promise<NodeResponse[]>;
+    get(id: string): Promise<NodeResponse>;
+    create(type: string, name: string, metadata?: Record<string, unknown>): Promise<NodeResponse>;
+    children(id: string): Promise<NodeResponse[]>;
+}
+declare class SqlSubmodule {
+    private readonly client;
+    constructor(client: SovariaClient);
+    createTable(tableName: string, columns: ColumnDefinition[]): Promise<Record<string, unknown>>;
+    query(sql: string, params?: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    dropTable(name: string): Promise<Record<string, unknown>>;
+}
+declare class DocSubmodule {
+    private readonly client;
+    constructor(client: SovariaClient);
+    put(collection: string, key: string, data: Record<string, unknown>): Promise<DocumentPutResponse>;
+    get(collection: string, key: string): Promise<DocumentGetResponse>;
+    scan(collection: string, filter?: Record<string, unknown>): Promise<DocumentScanResult>;
+}
+declare class DataModule {
+    readonly sql: SqlSubmodule;
+    readonly doc: DocSubmodule;
+    constructor(client: SovariaClient);
+}
+declare class StorageModule {
+    private readonly client;
+    constructor(client: SovariaClient);
+    listBuckets(): Promise<Bucket[]>;
+    createBucket(name: string, isPublic?: boolean): Promise<Bucket>;
+    listObjects(bucket: string): Promise<StorageObject[]>;
+    uploadObject(bucket: string, path: string, body: string | Blob | ArrayBuffer | ReadableStream, contentType?: string): Promise<StorageObject>;
+    deleteObject(bucket: string, path: string): Promise<void>;
+}
+declare class FunctionsModule {
+    private readonly client;
+    constructor(client: SovariaClient);
+    deploy(name: string, code: string, runtime: string, entrypoint?: string): Promise<FunctionDeployResponse>;
+    invoke(name: string, payload?: unknown): Promise<FunctionInvokeResponse>;
+}
+declare class RealtimeModule {
+    private readonly client;
+    constructor(client: SovariaClient);
+    /**
+     * Subscribe to a realtime channel via WebSocket.
+     *
+     * Uses a short-lived ticket so JWTs are never placed in WebSocket URLs.
+     *
+     * Returns a subscription handle with an `unsubscribe()` method.
+     */
+    subscribe(channel: string, callback: RealtimeCallback): RealtimeSubscription;
+}
+declare class ChronoModule {
+    private readonly client;
+    constructor(client: SovariaClient);
+    log(timelineName: string): Promise<TimelineLogResponse>;
+    jump(timelineName: string, targetHex: string): Promise<TimelineJumpResponse>;
+}
+export {};