@rebasepro/client 0.6.0 → 0.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/client",
   "type": "module",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "HTTP SDK client for the Rebase custom backend",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -20,6 +20,13 @@
   "engines": {
     "node": ">=14"
   },
+  "scripts": {
+    "watch": "vite build --watch",
+    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json",
+    "test:lint": "eslint \"src/**\" --quiet",
+    "test": "jest --passWithNoTests --forceExit",
+    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -30,9 +37,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/common": "0.6.0",
-    "@rebasepro/utils": "0.6.0",
-    "@rebasepro/types": "0.6.0"
+    "@rebasepro/common": "workspace:*",
+    "@rebasepro/types": "workspace:*",
+    "@rebasepro/utils": "workspace:*"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",
@@ -71,12 +78,5 @@
       "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
       "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts"
     }
-  },
-  "scripts": {
-    "watch": "vite build --watch",
-    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json",
-    "test:lint": "eslint \"src/**\" --quiet",
-    "test": "jest --passWithNoTests --forceExit",
-    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"
   }
-}
+}

package/src/admin.ts

@@ -53,6 +53,23 @@ export function createAdmin(transport: Transport, options?: CreateAdminOptions)
         });
     }
 
+    async function resetPassword(userId: string, options?: { password?: string }) {
+        return transport.request<{ user: AdminUser; temporaryPassword?: string; invitationSent?: boolean }>(
+            adminPath + "/users/" + encodeURIComponent(userId) + "/reset-password",
+            {
+                method: "POST",
+                ...(options?.password ? { body: JSON.stringify({ password: options.password }) } : {})
+            }
+        );
+    }
+
+    async function listRoles() {
+        return transport.request<{ roles: Array<{ id: string; name: string }> }>(
+            adminPath + "/roles",
+            { method: "GET" }
+        );
+    }
+
     async function bootstrap() {
         return transport.request<{ success: boolean; message: string; user: { uid: string; roles: string[] } }>(adminPath + "/bootstrap", {
             method: "POST"
@@ -66,6 +83,8 @@ export function createAdmin(transport: Transport, options?: CreateAdminOptions)
         createUser,
         updateUser,
         deleteUser,
+        resetPassword,
+        listRoles,
         bootstrap
     };
 }

package/src/api-keys.ts

@@ -0,0 +1,109 @@
+import type { Transport } from "./transport";
+
+// Re-define the types locally since they live in server-core, not in @rebasepro/types.
+// These match the server-side types exactly.
+
+/** 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[];
+    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 function createApiKeys(transport: Transport, options?: CreateApiKeysOptions) {
+    const apiKeysPath = options?.apiKeysPath || "/admin/api-keys";
+
+    /** List all API keys (masked). */
+    async function listKeys(): Promise<{ keys: ApiKeyMasked[] }> {
+        return transport.request<{ keys: ApiKeyMasked[] }>(apiKeysPath, { method: "GET" });
+    }
+
+    /** Get a single API key by ID (masked). */
+    async function getKey(id: string): Promise<{ key: ApiKeyMasked }> {
+        return transport.request<{ key: ApiKeyMasked }>(
+            apiKeysPath + "/" + encodeURIComponent(id),
+            { method: "GET" }
+        );
+    }
+
+    /** Create a new API key. The full secret is included in the response. */
+    async function createKey(data: CreateApiKeyRequest): Promise<{ key: ApiKeyWithSecret }> {
+        return transport.request<{ key: ApiKeyWithSecret }>(apiKeysPath, {
+            method: "POST",
+            body: JSON.stringify(data)
+        });
+    }
+
+    /** Update an existing API key. */
+    async function updateKey(id: string, data: UpdateApiKeyRequest): Promise<{ key: ApiKeyMasked }> {
+        return transport.request<{ key: ApiKeyMasked }>(
+            apiKeysPath + "/" + encodeURIComponent(id),
+            {
+                method: "PUT",
+                body: JSON.stringify(data)
+            }
+        );
+    }
+
+    /** Revoke (soft-delete) an API key. */
+    async function revokeKey(id: string): Promise<{ success: boolean }> {
+        return transport.request<{ success: boolean }>(
+            apiKeysPath + "/" + encodeURIComponent(id),
+            { method: "DELETE" }
+        );
+    }
+
+    return {
+        listKeys,
+        getKey,
+        createKey,
+        updateKey,
+        revokeKey
+    };
+}

package/src/auth.ts

@@ -35,6 +35,7 @@ export interface AuthConfig {
     emailServiceEnabled?: boolean;
     passwordReset?: boolean;
     emailVerification?: boolean;
+    magicLink?: boolean;
     enabledProviders: string[];
 }
 
@@ -428,6 +429,33 @@ newPassword })
         return body as { success: boolean; message: string; };
     }
 
+    async function sendMagicLink(email: string) {
+        const fetchFn = getFetch();
+        const res = await fetchFn(authUrl("/magic-link"), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ email })
+        });
+        const body = await res.json().catch(() => ({}));
+        if (!res.ok) throwApiError(res.status, body, res.statusText);
+        return body as { success: boolean; message: string; };
+    }
+
+    async function verifyMagicLink(token: string) {
+        const fetchFn = getFetch();
+        const res = await fetchFn(authUrl("/magic-link/verify"), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ token })
+        });
+        const body = await res.json().catch(() => ({}));
+        if (!res.ok) throwApiError(res.status, body, res.statusText);
+        const session = handleAuthResponse(body, "SIGNED_IN");
+        return { user: session.user,
+accessToken: session.accessToken,
+refreshToken: session.refreshToken };
+    }
+
     async function getSessions() {
         const data = await transport.request<{ sessions: Record<string, unknown>[] }>(authPath + "/sessions", { method: "GET" });
         return data.sessions;
@@ -517,6 +545,8 @@ newPassword })
         changePassword,
         sendVerificationEmail,
         verifyEmail,
+        sendMagicLink,
+        verifyMagicLink,
         getSessions,
         revokeSession,
         revokeAllSessions,

package/src/index.ts

@@ -2,6 +2,7 @@ import { createTransport, 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 { createCollectionClient, CollectionClient } from "./collection";
 import { createFunctionsClient } from "./functions";
 import { createStorage } from "./storage";
@@ -13,6 +14,7 @@ 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";
@@ -25,6 +27,7 @@ export interface CreateRebaseClientOptions extends RebaseClientConfig {
     auth?: CreateAuthOptions;
     admin?: CreateAdminOptions;
     cron?: CreateCronOptions;
+    apiKeys?: CreateApiKeysOptions;
 }
 
 // ─── Typed Data Proxy ────────────────────────────────────────────────────────
@@ -62,6 +65,7 @@ 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;
@@ -110,6 +114,7 @@ export function createRebaseClient<DB = Record<string, unknown>>(options: Create
     const auth = createAuth(transport, options.auth);
     const admin = createAdmin(transport, options.admin);
     const cron = createCron(transport, options.cron);
+    const apiKeys = createApiKeys(transport, options.apiKeys);
     const storage = createStorage(transport);
     const functions = createFunctionsClient(transport);
 
@@ -198,6 +203,7 @@ export function createRebaseClient<DB = Record<string, unknown>>(options: Create
         auth,
         admin,
         cron,
+        apiKeys,
         functions,
         storage,
         ws,

package/src/transport.ts

@@ -90,7 +90,7 @@ function normalizeWhereValue(value: WhereFieldValue): string {
 
 function serializeLogicalCondition(cond: any): string {
     if ("type" in cond) {
-        const sub = cond.conditions.map(serializeLogicalCondition).join(",");
+        const sub = (cond.conditions ?? []).map(serializeLogicalCondition).join(",");
         return `${cond.type}(${sub})`;
     } else {
         const op = OP_MAP[cond.operator] ?? cond.operator;
@@ -126,7 +126,7 @@ export function buildQueryString(params?: FindParams): string {
 
     if (params.logical) {
         const root = params.logical;
-        const serialized = root.conditions.map(serializeLogicalCondition).join(",");
+        const serialized = (root.conditions ?? []).map(serializeLogicalCondition).join(",");
         parts.push(`${root.type}=${encodeURIComponent(`(${serialized})`)}`);
     }
 

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Rebase
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.