@rebasepro/client 0.6.1 → 0.8.0

package/dist/admin.d.ts

@@ -42,6 +42,19 @@ export declare function createAdmin(transport: Transport, options?: CreateAdminO
     deleteUser: (userId: string) => Promise<{
         success: boolean;
     }>;
+    resetPassword: (userId: string, options?: {
+        password?: string;
+    }) => Promise<{
+        user: AdminUser;
+        temporaryPassword?: string;
+        invitationSent?: boolean;
+    }>;
+    listRoles: () => Promise<{
+        roles: Array<{
+            id: string;
+            name: string;
+        }>;
+    }>;
     bootstrap: () => Promise<{
         success: boolean;
         message: string;

package/dist/api-keys.d.ts

@@ -0,0 +1,66 @@
+import type { Transport } from "./transport";
+/** A single permission entry scoping an API key to a collection and its allowed operations. */
+export interface ApiKeyPermission {
+    collection: string;
+    operations: ("read" | "write" | "delete")[];
+}
+/** An API key with the secret portion masked (returned by list / get / update). */
+export interface ApiKeyMasked {
+    id: string;
+    name: string;
+    key_prefix: string;
+    permissions: ApiKeyPermission[];
+    admin: boolean;
+    rate_limit: number | null;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+    last_used_at: string | null;
+    expires_at: string | null;
+    revoked_at: string | null;
+}
+/** An API key including the full secret (returned only on creation). */
+export interface ApiKeyWithSecret extends ApiKeyMasked {
+    key: string;
+}
+/** Payload for creating a new API key. */
+export interface CreateApiKeyRequest {
+    name: string;
+    permissions: ApiKeyPermission[];
+    rate_limit?: number | null;
+    expires_at?: string | null;
+}
+/** Payload for updating an existing API key. */
+export interface UpdateApiKeyRequest {
+    name?: string;
+    permissions?: ApiKeyPermission[];
+    rate_limit?: number | null;
+    expires_at?: string | null;
+}
+/** Options for the `createApiKeys` factory. */
+export interface CreateApiKeysOptions {
+    apiKeysPath?: string;
+}
+/**
+ * Creates a client for managing API keys via the admin routes.
+ *
+ * @param transport - The shared HTTP transport created by `createTransport`.
+ * @param options   - Optional overrides (e.g. a custom base path).
+ */
+export declare function createApiKeys(transport: Transport, options?: CreateApiKeysOptions): {
+    listKeys: () => Promise<{
+        keys: ApiKeyMasked[];
+    }>;
+    getKey: (id: string) => Promise<{
+        key: ApiKeyMasked;
+    }>;
+    createKey: (data: CreateApiKeyRequest) => Promise<{
+        key: ApiKeyWithSecret;
+    }>;
+    updateKey: (id: string, data: UpdateApiKeyRequest) => Promise<{
+        key: ApiKeyMasked;
+    }>;
+    revokeKey: (id: string) => Promise<{
+        success: boolean;
+    }>;
+};

package/dist/auth.d.ts

@@ -28,6 +28,7 @@ export interface AuthConfig {
     emailServiceEnabled?: boolean;
     passwordReset?: boolean;
     emailVerification?: boolean;
+    magicLink?: boolean;
     enabledProviders: string[];
 }
 export interface AuthStorage {
@@ -158,6 +159,15 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
         success: boolean;
         message: string;
     }>;
+    sendMagicLink: (email: string) => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    verifyMagicLink: (token: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
     getSessions: () => Promise<Record<string, unknown>[]>;
     revokeSession: (sessionId: string) => Promise<{
         success: boolean;

package/dist/collection.d.ts

@@ -1,6 +1,6 @@
 import { FindParams, Transport } from "./transport";
 import { RebaseWebSocketClient } from "./websocket";
-import { CollectionAccessor, FilterOperator, LogicalCondition, WhereValue } from "@rebasepro/types";
+import { CollectionAccessor, LogicalCondition, WhereFilterOp, WhereValue } from "@rebasepro/types";
 import { QueryBuilder } from "./query_builder";
 /**
  * CollectionClient extends `CollectionAccessor` from `@rebasepro/types` so that
@@ -9,9 +9,9 @@ import { QueryBuilder } from "./query_builder";
  * 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<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): QueryBuilder<M>;
+    where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): QueryBuilder<M>;
     where(logicalCondition: LogicalCondition): QueryBuilder<M>;
-    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilder<M>;
+    orderBy(column: keyof M & string, direction?: "asc" | "desc"): QueryBuilder<M>;
     limit(count: number): QueryBuilder<M>;
     offset(count: number): QueryBuilder<M>;
     search(searchString: string): QueryBuilder<M>;

package/dist/index.d.ts

@@ -2,18 +2,21 @@ import { RebaseClientConfig } from "./transport";
 import { createAuth, CreateAuthOptions } from "./auth";
 import { createAdmin, CreateAdminOptions } from "./admin";
 import { createCron, CreateCronOptions } from "./cron";
+import { createApiKeys, CreateApiKeysOptions } from "./api-keys";
 import { CollectionClient } from "./collection";
 import { createFunctionsClient } from "./functions";
 import { RebaseWebSocketClient } from "./websocket";
-import { RebaseClient, RebaseData, StorageSource } from "@rebasepro/types";
+import { RebaseClient, RebaseData, StorageSource, StorageSourceDefinition, StorageSourceRegistry } from "@rebasepro/types";
 export * from "./transport";
 export * from "./auth";
 export * from "./admin";
 export * from "./cron";
+export * from "./api-keys";
 export * from "./collection";
 export * from "./query_builder";
 export * from "./websocket";
 export * from "./storage";
+export * from "./storage-registry";
 export * from "./reviver";
 export * from "./functions";
 export type { Entity, FindResponse } from "@rebasepro/types";
@@ -21,6 +24,22 @@ export interface CreateRebaseClientOptions extends RebaseClientConfig {
     auth?: CreateAuthOptions;
     admin?: CreateAdminOptions;
     cron?: CreateCronOptions;
+    apiKeys?: CreateApiKeysOptions;
+    /**
+     * Declared storage sources for multi-backend support. Server-transport
+     * entries are auto-wired into `client.storageRegistry`; `direct` sources
+     * are registered app-side (e.g. via a Firebase Storage hook). The default
+     * source (`storage`) is always registered under
+     * {@link DEFAULT_STORAGE_SOURCE_KEY}.
+     */
+    storageSources?: StorageSourceDefinition[];
+    /**
+     * Maps camelCase property names / safe identifiers to the actual
+     * collection slugs on the server (e.g. `{ companyMembers: "company-members" }`).
+     * If provided, the data layer proxy will resolve property accessors to their
+     * correct slugs via this map before falling back to automatic snake_casing.
+     */
+    collections?: Record<string, string>;
 }
 type KebabToCamelCase<S extends string> = S extends `${infer T}-${infer U}` ? `${T}${Capitalize<KebabToCamelCase<U>>}` : S;
 type TypedDataLayer<DB> = {
@@ -47,9 +66,13 @@ export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<Rebase
     auth: ReturnType<typeof createAuth>;
     admin: ReturnType<typeof createAdmin>;
     cron: ReturnType<typeof createCron>;
+    apiKeys: ReturnType<typeof createApiKeys>;
     functions: ReturnType<typeof createFunctionsClient>;
     ws?: RebaseWebSocketClient;
     storage: StorageSource;
+    storageRegistry: StorageSourceRegistry;
+    createStorageSource: (storageId: string) => StorageSource;
+    fetchStorageSources: () => Promise<StorageSourceDefinition[]>;
     call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
     data: TypedDataLayer<DB>;
 };