@rebasepro/client-postgresql 0.0.1-canary.09e5ec5

package/LICENSE

@@ -0,0 +1,6 @@
+Source code in this repository is variously licensed under the Business Source
+License 1.1 (BSL), Apache version 2.0 and the MIT license. A copy of each
+license can be found in each one of the packages under the folder packages
+under a file called License. Source code in a given file is licensed under the
+BSL and the copyright belongs to Rebase Authors unless otherwise noted at the
+beginning of the file.

package/README.md

@@ -0,0 +1,106 @@
+# @rebasepro/postgresql
+
+PostgreSQL data source client for Rebase with real-time WebSocket connectivity.
+
+This package provides a complete client-side implementation for connecting Rebase applications to PostgreSQL backends, featuring real-time synchronization via WebSockets.
+
+## Installation
+
+```bash
+npm install @rebasepro/postgresql @rebasepro/core
+```
+
+## Usage
+
+### Basic Setup with React Hook
+
+```typescript
+import { usePostgresDataSource } from "@rebasepro/postgresql";
+import { Rebase } from "@rebasepro/core";
+
+function App() {
+    const dataSource = usePostgresDataSource({
+        baseUrl: "http://localhost:3001",
+        websocketUrl: "ws://localhost:3001", // Optional, will be inferred from baseUrl
+        headers: { // Optional
+            "Authorization": "Bearer your-token"
+        }
+    });
+
+    return (
+        <Rebase
+            dataSource={dataSource}
+            collections={collections}
+            // ... other props
+        />
+    );
+}
+```
+
+### Creating Data Source Directly
+
+```typescript
+import { createPostgresDataSource } from "@rebasepro/postgresql";
+
+const dataSource = createPostgresDataSource({
+    baseUrl: "http://localhost:3001",
+    websocketUrl: "ws://localhost:3001"
+});
+```
+
+## Features
+
+- **Real-time Synchronization**: WebSocket-based real-time updates for collections and entities
+- **Automatic Reconnection**: Built-in reconnection logic with exponential backoff
+- **Type Safety**: Full TypeScript support with Rebase core types
+- **Error Handling**: Comprehensive error handling with custom error types
+- **Connection Management**: Connection status monitoring and queue management
+
+## API
+
+### Configuration
+
+```typescript
+interface PostgresDataSourceConfig {
+    baseUrl: string;           // Backend server URL
+    websocketUrl?: string;     // WebSocket URL (optional)
+    headers?: Record<string, string>; // Custom headers (optional)
+}
+```
+
+### Methods
+
+The PostgreSQL data source implements all Rebase `DataSource` methods:
+
+- `fetchCollection<M>(props): Promise<Entity<M>[]>`
+- `fetchEntity<M>(props): Promise<Entity<M> | undefined>`
+- `saveEntity<M>(props): Promise<Entity<M>>`
+- `deleteEntity<M>(props): Promise<void>`
+- `checkUniqueField(...): Promise<boolean>`
+- `generateEntityId(...): string`
+- `countEntities<M>(props): Promise<number>`
+- `listenCollection<M>(props): () => void`
+- `listenEntity<M>(props): () => void`
+
+## Backend Requirements
+
+This client expects a WebSocket-enabled backend that handles the following message types:
+
+- `FETCH_COLLECTION`
+- `FETCH_ENTITY`
+- `SAVE_ENTITY`
+- `DELETE_ENTITY`
+- `CHECK_UNIQUE_FIELD`
+- `GENERATE_ENTITY_ID`
+- `COUNT_ENTITIES`
+- `subscribe_collection`
+- `subscribe_entity`
+- `unsubscribe`
+
+## Development
+
+This package is part of the Rebase monorepo. For development instructions, see the main repository README.
+
+## License
+
+MIT

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

@@ -0,0 +1,94 @@
+import { Transport } from "./transport";
+export interface AdminUser {
+    uid: string;
+    email: string;
+    displayName: string | null;
+    photoURL: string | null;
+    provider: string;
+    roles: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RebaseRole {
+    id: string;
+    name: string;
+    isAdmin: boolean;
+    defaultPermissions: Record<string, unknown> | null;
+    config: Record<string, unknown> | null;
+}
+export interface CreateAdminOptions {
+    adminPath?: string;
+}
+export declare function createAdmin(transport: Transport, options?: CreateAdminOptions): {
+    listUsers: () => Promise<{
+        users: AdminUser[];
+    }>;
+    listUsersPaginated: (options?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+        orderDir?: "asc" | "desc";
+    }) => Promise<{
+        users: AdminUser[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getUser: (userId: string) => Promise<{
+        user: AdminUser;
+    }>;
+    createUser: (data: {
+        email: string;
+        displayName?: string;
+        password?: string;
+        roles?: string[];
+    }) => Promise<{
+        user: AdminUser;
+    }>;
+    updateUser: (userId: string, data: {
+        email?: string;
+        displayName?: string;
+        password?: string;
+        roles?: string[];
+    }) => Promise<{
+        user: AdminUser;
+    }>;
+    deleteUser: (userId: string) => Promise<{
+        success: boolean;
+    }>;
+    listRoles: () => Promise<{
+        roles: RebaseRole[];
+    }>;
+    getRole: (roleId: string) => Promise<{
+        role: RebaseRole;
+    }>;
+    createRole: (data: {
+        id: string;
+        name: string;
+        isAdmin?: boolean;
+        defaultPermissions?: Record<string, unknown>;
+        config?: Record<string, unknown>;
+    }) => Promise<{
+        role: RebaseRole;
+    }>;
+    updateRole: (roleId: string, data: {
+        name?: string;
+        isAdmin?: boolean;
+        defaultPermissions?: Record<string, unknown>;
+        config?: Record<string, unknown>;
+    }) => Promise<{
+        role: RebaseRole;
+    }>;
+    deleteRole: (roleId: string) => Promise<{
+        success: boolean;
+    }>;
+    bootstrap: () => Promise<{
+        success: boolean;
+        message: string;
+        user: {
+            uid: string;
+            roles: string[];
+        };
+    }>;
+};

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

@@ -0,0 +1,161 @@
+import { Transport } from "./transport";
+export interface RebaseUser {
+    uid: string;
+    email: string | null;
+    displayName: string | null;
+    photoURL: string | null;
+    emailVerified?: boolean;
+    roles?: string[];
+    providerId: string;
+    isAnonymous: boolean;
+}
+export interface RebaseTokens {
+    accessToken: string;
+    refreshToken: string;
+    accessTokenExpiresAt: number;
+}
+export interface RebaseSession {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    user: RebaseUser;
+}
+export type AuthChangeEvent = "SIGNED_IN" | "SIGNED_OUT" | "TOKEN_REFRESHED" | "USER_UPDATED";
+export interface AuthConfig {
+    needsSetup: boolean;
+    registrationEnabled: boolean;
+    googleEnabled: boolean;
+    emailServiceEnabled: boolean;
+}
+export interface AuthStorage {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+}
+export declare function createMemoryStorage(): AuthStorage;
+export interface CreateAuthOptions {
+    storage?: AuthStorage;
+    authPath?: string;
+    autoRefresh?: boolean;
+    persistSession?: boolean;
+}
+export declare function createAuth(transport: Transport, options?: CreateAuthOptions): {
+    signInWithEmail: (email: string, password: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signUp: (email: string, password: string, displayName?: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithGoogle: (idToken: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithLinkedin: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithOAuth: (providerId: string, payload: Record<string, unknown>) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithGitHub: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithMicrosoft: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithApple: (code: string, redirectUri: string, user?: {
+        name?: {
+            firstName?: string;
+            lastName?: string;
+        };
+        email?: string;
+    }) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithFacebook: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithTwitter: (code: string, redirectUri: string, codeVerifier: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithDiscord: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithGitLab: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithBitbucket: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithSlack: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithSpotify: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signOut: () => Promise<void>;
+    refreshSession: () => Promise<RebaseSession>;
+    getUser: () => Promise<RebaseUser>;
+    updateUser: (updates: {
+        displayName?: string;
+        photoURL?: string;
+    }) => Promise<RebaseUser>;
+    resetPasswordForEmail: (email: string) => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    resetPassword: (token: string, password: string) => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    changePassword: (oldPassword: string, newPassword: string) => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    sendVerificationEmail: () => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    verifyEmail: (token: string) => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getSessions: () => Promise<Record<string, unknown>[]>;
+    revokeSession: (sessionId: string) => Promise<{
+        success: boolean;
+    }>;
+    revokeAllSessions: () => Promise<{
+        success: boolean;
+    }>;
+    getAuthConfig: () => Promise<AuthConfig>;
+    getSession: () => RebaseSession | null;
+    onAuthStateChange: (callback: (event: AuthChangeEvent, session: RebaseSession | null) => void) => () => boolean;
+};

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

@@ -0,0 +1,19 @@
+import { Transport } from "./transport";
+import { RebaseWebSocketClient } from "./websocket";
+import { CollectionAccessor } from "@rebasepro/types";
+import { FilterOperator, QueryBuilder } from "./query_builder";
+/**
+ * CollectionClient extends `CollectionAccessor` from `@rebasepro/types` so that
+ * `client.data` can be passed directly to the core Rebase component.
+ *
+ * Additionally it exposes fluent query builder methods like `.where()`, `.orderBy()`.
+ */
+export interface CollectionClient<M extends Record<string, unknown> = Record<string, unknown>> extends CollectionAccessor<M> {
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): QueryBuilder<M>;
+    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilder<M>;
+    limit(count: number): QueryBuilder<M>;
+    offset(count: number): QueryBuilder<M>;
+    search(searchString: string): QueryBuilder<M>;
+    include(...relations: string[]): QueryBuilder<M>;
+}
+export declare function createCollectionClient<M extends Record<string, unknown> = Record<string, unknown>>(transport: Transport, slug: string, ws?: RebaseWebSocketClient): CollectionClient<M>;

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

@@ -0,0 +1,25 @@
+import { Transport } from "./transport";
+import type { CronJobStatus, CronJobLogEntry } from "@rebasepro/types";
+export interface CreateCronOptions {
+    cronPath?: string;
+}
+export declare function createCron(transport: Transport, options?: CreateCronOptions): {
+    listJobs: () => Promise<{
+        jobs: CronJobStatus[];
+    }>;
+    getJob: (jobId: string) => Promise<{
+        job: CronJobStatus;
+    }>;
+    triggerJob: (jobId: string) => Promise<{
+        log: CronJobLogEntry;
+        job: CronJobStatus;
+    }>;
+    getJobLogs: (jobId: string, options?: {
+        limit?: number;
+    }) => Promise<{
+        logs: CronJobLogEntry[];
+    }>;
+    toggleJob: (jobId: string, enabled: boolean) => Promise<{
+        job: CronJobStatus;
+    }>;
+};

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

@@ -0,0 +1,42 @@
+import { RebaseClientConfig } from "./transport";
+import { createAuth, CreateAuthOptions } from "./auth";
+import { createAdmin, CreateAdminOptions } from "./admin";
+import { createCron, CreateCronOptions } from "./cron";
+import { CollectionClient } from "./collection";
+export * from "./transport";
+export * from "./auth";
+export * from "./admin";
+export * from "./cron";
+export * from "./collection";
+export * from "./websocket";
+export * from "./storage";
+export * from "./reviver";
+export interface CreateRebaseClientOptions extends RebaseClientConfig {
+    auth?: CreateAuthOptions;
+    admin?: CreateAdminOptions;
+    cron?: CreateCronOptions;
+}
+import { RebaseWebSocketClient } from "./websocket";
+import { RebaseClient as BaseRebaseClient, RebaseData, StorageSource } from "@rebasepro/types";
+export type RebaseClient<DB = Record<string, unknown>> = BaseRebaseClient<DB> & {
+    setToken: (token: string | null) => void;
+    setAuthTokenGetter: (getter: () => Promise<string | null>) => void;
+    setOnUnauthorized: (handler: () => Promise<boolean>) => void;
+    resolveToken: () => Promise<string | null>;
+    auth: ReturnType<typeof createAuth>;
+    admin: ReturnType<typeof createAdmin>;
+    cron: ReturnType<typeof createCron>;
+    ws?: RebaseWebSocketClient;
+    storage?: StorageSource;
+    call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
+    data: RebaseData & {
+        collection<K extends keyof DB>(slug: Extract<K, string>): CollectionClient<DB[K] extends {
+            Row: infer R extends Record<string, unknown>;
+        } ? R : Record<string, unknown>>;
+    } & {
+        [K in keyof DB]: CollectionClient<DB[K] extends {
+            Row: infer R extends Record<string, unknown>;
+        } ? R : Record<string, unknown>>;
+    };
+};
+export declare function createRebaseClient<DB = Record<string, unknown>>(options: CreateRebaseClientOptions): RebaseClient<DB>;

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

@@ -0,0 +1,53 @@
+import { FindResponse } from "@rebasepro/types";
+import { CollectionClient } from "./collection";
+export type FilterOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "cs" | "csa" | "==" | "!=" | ">" | ">=" | "<" | "<=" | "array-contains" | "array-contains-any" | "not-in";
+export declare class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> {
+    private collection;
+    private params;
+    constructor(collection: CollectionClient<M>);
+    /**
+     * Add a filter condition to your query.
+     * @example
+     * client.collection('users').where('age', '>=', 18).find()
+     */
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): this;
+    /**
+     * Order the results by a specific column.
+     * @example
+     * client.collection('users').orderBy('createdAt', 'desc').find()
+     */
+    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
+    /**
+     * Limit the number of results returned.
+     */
+    limit(count: number): this;
+    /**
+     * Skip the first N results.
+     */
+    offset(count: number): this;
+    /**
+     * Set a free-text search string if supported by the backend.
+     */
+    search(searchString: string): this;
+    /**
+     * Include related entities in the response.
+     * Relations will be populated with full entity data instead of just IDs.
+     *
+     * @param relations - Relation names to include, or "*" for all.
+     * @example
+     * // Include specific relations
+     * client.data.posts.include("tags", "author").find()
+     *
+     * // Include all relations
+     * client.data.posts.include("*").find()
+     */
+    include(...relations: string[]): this;
+    /**
+     * Execute the find query and return the results.
+     */
+    find(): Promise<FindResponse<M>>;
+    /**
+     * Listen to realtime updates matching this query.
+     */
+    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
+}

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

@@ -0,0 +1 @@
+export declare function rebaseReviver(_key: string, value: unknown): unknown;

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

@@ -0,0 +1,3 @@
+import { StorageSource } from "@rebasepro/types";
+import { Transport } from "./transport";
+export declare function createStorage(transport: Transport): StorageSource;

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

@@ -0,0 +1,33 @@
+import { FindParams as TypesFindParams, FindResponse as TypesFindResponse } from "@rebasepro/types";
+export interface RebaseClientConfig {
+    baseUrl?: string;
+    token?: string;
+    apiPath?: string;
+    fetch?: typeof globalThis.fetch;
+    onUnauthorized?: () => Promise<boolean>;
+    websocketUrl?: string;
+}
+/**
+ * Re-export from `@rebasepro/types` for backward compatibility.
+ */
+export type FindParams = TypesFindParams;
+export type FindResponse<T> = TypesFindResponse<T extends Record<string, unknown> ? T : Record<string, unknown>>;
+export declare class RebaseApiError extends Error {
+    status: number;
+    code?: string;
+    details?: unknown;
+    constructor(status: number, message: string, code?: string, details?: unknown);
+}
+export declare function buildQueryString(params?: FindParams): string;
+export interface Transport {
+    request: <T = unknown>(path: string, init?: RequestInit) => Promise<T>;
+    setToken: (newToken: string | null) => void;
+    setAuthTokenGetter: (getter: () => Promise<string | null>) => void;
+    setOnUnauthorized: (handler: () => Promise<boolean>) => void;
+    readonly baseUrl: string;
+    readonly apiPath: string;
+    readonly fetchFn: typeof globalThis.fetch;
+    getHeaders: (init?: RequestInit) => Record<string, string>;
+    resolveToken: () => Promise<string | null>;
+}
+export declare function createTransport(config: RebaseClientConfig): Transport;

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

@@ -0,0 +1,99 @@
+import { DeleteEntityProps, Entity, EntityCollection, FetchCollectionProps, FetchEntityProps, SaveEntityProps, TableMetadata, BranchInfo } from "@rebasepro/types";
+export interface RebaseWebSocketConfig {
+    websocketUrl: string;
+    /** Optional auth token getter for WebSocket authentication */
+    getAuthToken?: () => Promise<string>;
+    /** Optional WebSocket constructor to override globalThis.WebSocket (e.g. for Node environments) */
+    WebSocket?: typeof WebSocket;
+}
+export declare class ApiError extends Error {
+    code?: string;
+    error?: string;
+    constructor(message: string, error?: string, code?: string);
+}
+export declare class RebaseWebSocketClient {
+    private websocketUrl;
+    private ws;
+    getAuthToken?: () => Promise<string>;
+    private subscriptions;
+    private listeners;
+    on(event: "connect" | "disconnect" | "reconnect" | "error", cb: (...args: unknown[]) => void): () => boolean;
+    private emit;
+    private collectionSubscriptions;
+    private entitySubscriptions;
+    private backendToCollectionKey;
+    private backendToEntityKey;
+    private pendingRequests;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private isConnected;
+    private messageQueue;
+    private reconnectTimeout;
+    private isAuthenticated;
+    private authPromise;
+    private WebSocketConstructor;
+    constructor(config: RebaseWebSocketConfig);
+    /**
+     * Authenticate the WebSocket connection
+     */
+    authenticate(token: string): Promise<void>;
+    /**
+     * Set the auth token getter function
+     */
+    setAuthTokenGetter(getAuthToken: () => Promise<string>): void;
+    disconnect(): void;
+    private initWebSocket;
+    private processMessageQueue;
+    private attemptReconnect;
+    private handleWebSocketMessage;
+    private ensureAuthenticated;
+    /**
+     * Force re-authentication (call after token refresh)
+     */
+    reauthenticate(): Promise<void>;
+    private sendMessage;
+    private doSendMessage;
+    fetchCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]>;
+    fetchEntity<M extends Record<string, unknown>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
+    saveEntity<M extends Record<string, unknown>>(props: SaveEntityProps<M>): Promise<Entity<M>>;
+    deleteEntity<M extends Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void>;
+    executeSql(sql: string, options?: {
+        database?: string;
+        role?: string;
+    }): Promise<Record<string, unknown>[]>;
+    fetchAvailableDatabases(): Promise<string[]>;
+    fetchAvailableRoles(): Promise<string[]>;
+    fetchCurrentDatabase(): Promise<string | undefined>;
+    checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
+    countEntities<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number>;
+    fetchUnmappedTables(mappedPaths?: string[]): Promise<string[]>;
+    fetchTableMetadata(tableName: string): Promise<TableMetadata>;
+    createBranch(name: string, options?: {
+        source?: string;
+    }): Promise<BranchInfo>;
+    deleteBranch(name: string): Promise<void>;
+    listBranches(): Promise<BranchInfo[]>;
+    /**
+     * Recursively compare two values for structural equality.
+     * Handles primitives, null, undefined, Date, RegExp, arrays, and plain objects.
+     */
+    private deepEqual;
+    private normalizeForComparison;
+    /**
+     * Merge incoming entities with cached data, preserving cached references
+     * for entities whose values haven't changed. This avoids unnecessary
+     * React re-renders when the server refetches all entities but most
+     * haven't actually changed.
+     */
+    private mergeEntities;
+    listenCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>, onUpdate: (entities: Entity[]) => void, onError?: (error: Error) => void): () => void;
+    listenEntity<M extends Record<string, unknown>>(props: FetchEntityProps<M>, onUpdate: (entity: Entity | null) => void, onError?: (error: Error) => void): () => void;
+    /**
+     * Re-send all active subscriptions to the backend after a reconnect.
+     * The server wipes subscription state when a client disconnects, so
+     * we need to re-register everything to resume receiving updates.
+     */
+    private resubscribeAll;
+    private createCollectionSubscriptionKey;
+    private createEntitySubscriptionKey;
+}

package/dist/client-postgresql/src/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @rebasepro/client-postgresql
+ *
+ * PostgreSQL data source client for Rebase
+ * This package provides a WebSocket-based client for connecting Rebase applications
+ * to PostgreSQL backends with real-time synchronization capabilities.
+ */
+export * from "./usePostgresClientDriver";

package/dist/client-postgresql/src/usePostgresClientDriver.d.ts

@@ -0,0 +1,9 @@
+import { DataDriver } from "@rebasepro/types";
+import { RebaseWebSocketClient } from "@rebasepro/client";
+export interface PostgresDataDriverConfig {
+    wsClient?: RebaseWebSocketClient;
+}
+export interface PostgresDataDriver extends DataDriver {
+    client?: RebaseWebSocketClient;
+}
+export declare function usePostgresClientDriver(config: PostgresDataDriverConfig): PostgresDataDriver;