@rebasepro/client 0.0.1-canary.4d4fb3e

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/dist/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, any> | null;
+    config: Record<string, any> | 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?: any;
+        config?: any;
+    }) => Promise<{
+        role: RebaseRole;
+    }>;
+    updateRole: (roleId: string, data: {
+        name?: string;
+        isAdmin?: boolean;
+        defaultPermissions?: any;
+        config?: any;
+    }) => Promise<{
+        role: RebaseRole;
+    }>;
+    deleteRole: (roleId: string) => Promise<{
+        success: boolean;
+    }>;
+    bootstrap: () => Promise<{
+        success: boolean;
+        message: string;
+        user: {
+            uid: string;
+            roles: string[];
+        };
+    }>;
+};

package/dist/auth.d.ts

@@ -0,0 +1,95 @@
+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;
+    }>;
+    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/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, any> = any> extends CollectionAccessor<M> {
+    where(column: keyof M & string, operator: FilterOperator, value: any): 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, any> = any>(transport: Transport, slug: string, ws?: RebaseWebSocketClient): CollectionClient<M>;

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { RebaseClientConfig } from "./transport";
+import { createAuth, CreateAuthOptions } from "./auth";
+import { createAdmin, CreateAdminOptions } from "./admin";
+import { CollectionClient } from "./collection";
+export * from "./transport";
+export * from "./auth";
+export * from "./admin";
+export * from "./collection";
+export * from "./websocket";
+export * from "./storage";
+export interface CreateRebaseClientOptions extends RebaseClientConfig {
+    auth?: CreateAuthOptions;
+    admin?: CreateAdminOptions;
+}
+import { RebaseWebSocketClient } from "./websocket";
+import { RebaseClient as BaseRebaseClient, RebaseData, StorageSource } from "@rebasepro/types";
+export type RebaseClient<DB = any> = 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>;
+    ws?: RebaseWebSocketClient;
+    storage?: StorageSource;
+    call: <T = any>(endpoint: string, payload?: any) => Promise<T>;
+    data: RebaseData & {
+        collection<K extends keyof DB>(slug: Extract<K, string>): CollectionClient<DB[K] extends {
+            Row: infer R extends Record<string, any>;
+        } ? R : any>;
+    } & {
+        [K in keyof DB]: CollectionClient<DB[K] extends {
+            Row: infer R extends Record<string, any>;
+        } ? R : any>;
+    };
+};
+export declare function createRebaseClient<DB = any>(options: CreateRebaseClientOptions): RebaseClient<DB>;