@rebasepro/client 0.11.1-canary.gfadf355 → 0.12.0

package/dist/realtime-channel.d.ts

@@ -49,14 +49,14 @@ export interface BroadcastEvent {
      */
     replayed?: boolean;
 }
-/** One retained message, as returned by {@link RebaseRealtimeChannel.history}. */
-export interface ChannelHistoryEntry {
-    seq: number;
-    event: string;
-    payload: unknown;
-    senderId?: string;
-    at?: string;
-}
+/**
+ * One retained message, as returned by {@link RebaseRealtimeChannel.history}.
+ *
+ * Re-exported rather than re-declared: the copy that used to live here had
+ * drifted `at` to optional, while the server always sends it.
+ */
+export type { ChannelHistoryEntry } from "@rebasepro/types";
+import type { ChannelHistoryEntry } from "@rebasepro/types";
 /** The answer to a catch-up request. */
 export interface ChannelHistoryResult {
     messages: ChannelHistoryEntry[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/client",
   "type": "module",
-  "version": "0.11.1-canary.gfadf355",
+  "version": "0.12.0",
   "description": "HTTP SDK client for the Rebase custom backend",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -29,9 +29,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/common": "0.11.1-canary.gfadf355",
-    "@rebasepro/types": "0.11.1-canary.gfadf355",
-    "@rebasepro/utils": "0.11.1-canary.gfadf355"
+    "@rebasepro/common": "0.12.0",
+    "@rebasepro/types": "0.12.0",
+    "@rebasepro/utils": "0.12.0"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",

package/src/api-keys.ts

@@ -1,50 +1,27 @@
 import type { Transport } from "./transport";
 
-// Re-define the types locally since they live in server, 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[];
-    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;
-}
+/**
+ * These were re-declared here, under a comment saying they lived in the server
+ * package rather than in `@rebasepro/types`. That stopped being true, and the
+ * copy drifted: it never gained `admin`, the flag that grants a key the `admin`
+ * role — admin routes plus the RLS `default_admin` policies — so the SDK could
+ * describe every kind of key except a privileged one, and
+ * `createKey({ …, admin: true })` was an excess-property error.
+ */
+export type {
+    ApiKeyPermission,
+    ApiKeyMasked,
+    ApiKeyWithSecret,
+    CreateApiKeyRequest,
+    UpdateApiKeyRequest
+} from "@rebasepro/types";
 
-/** Payload for updating an existing API key. */
-export interface UpdateApiKeyRequest {
-    name?: string;
-    permissions?: ApiKeyPermission[];
-    rate_limit?: number | null;
-    expires_at?: string | null;
-}
+import type {
+    ApiKeyMasked,
+    ApiKeyWithSecret,
+    CreateApiKeyRequest,
+    UpdateApiKeyRequest
+} from "@rebasepro/types";
 
 /** Options for the `createApiKeys` factory. */
 export interface CreateApiKeysOptions {

package/src/functions.ts

@@ -33,14 +33,8 @@ export interface FunctionsClient {
     ): Promise<T>;
 }
 
-export interface FunctionInvokeOptions {
-    /** HTTP method — defaults to `"POST"`. */
-    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-    /** Sub-path appended after the function name, e.g. `"status/123"`. */
-    path?: string;
-    /** Extra headers merged into the request (auth is still injected automatically). */
-    headers?: Record<string, string>;
-}
+export type { FunctionInvokeOptions } from "@rebasepro/types";
+import type { FunctionInvokeOptions } from "@rebasepro/types";
 
 /**
  * Create a `FunctionsClient` backed by the given transport.

package/src/offline-idb-store.test.ts

@@ -155,7 +155,40 @@ describe("row codec round-trip", () => {
     });
 });
 
+/**
+ * Empty the shared queue between the manager tests.
+ *
+ * `IDB_NAME` is a hardcoded `"rebase-offline"`, so every
+ * `new IndexedDBOfflineStore()` in this file opens the *same* database. The
+ * `IndexedDBOfflineStore` block above shares it deliberately — each of its
+ * tests uses its own key prefix, and one of them exists to prove that
+ * isolation holds. The two `OfflineManager` blocks below do not: a manager
+ * queues under no prefix, so without this they inherit each other's pending
+ * writes.
+ *
+ * CI failed both manager tests on 2026-07-28 with exactly the symptoms this
+ * coupling would produce — "replays them from a fresh one" asserted
+ * `flushed: 1` and got `2`, and the cross-tab read came back empty. It has not
+ * been reproduced locally (14 runs, including randomized order), so treat this
+ * as removing a real coupling rather than as a confirmed diagnosis: if CI fails
+ * here again, the shared queue is no longer the explanation and the next place
+ * to look is timing inside the manager itself.
+ */
+async function clearOfflineQueue(): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+        const request = indexedDB.deleteDatabase("rebase-offline");
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(request.error);
+        // A still-open connection blocks the delete; the manager tests each
+        // build their own stores, so resolving here keeps a stray one from
+        // hanging the suite rather than failing it.
+        request.onblocked = () => resolve();
+    });
+}
+
 describe("two tabs over one database", () => {
+    beforeEach(clearOfflineQueue);
+
     /** BroadcastChannel delivery is asynchronous; give it a macrotask or two. */
     const settle = async () => {
         for (let i = 0; i < 3; i++) await new Promise((resolve) => setTimeout(resolve, 0));
@@ -240,6 +273,8 @@ describe("two tabs over one database", () => {
 });
 
 describe("OfflineManager over IndexedDB", () => {
+    beforeEach(clearOfflineQueue);
+
     it("queues offline writes in one manager and replays them from a fresh one", async () => {
         const table = new Map<string, Record<string, unknown>>();
         const state = { online: true };

package/src/realtime-channel.ts

@@ -53,14 +53,14 @@ export interface BroadcastEvent {
     replayed?: boolean;
 }
 
-/** One retained message, as returned by {@link RebaseRealtimeChannel.history}. */
-export interface ChannelHistoryEntry {
-    seq: number;
-    event: string;
-    payload: unknown;
-    senderId?: string;
-    at?: string;
-}
+/**
+ * One retained message, as returned by {@link RebaseRealtimeChannel.history}.
+ *
+ * Re-exported rather than re-declared: the copy that used to live here had
+ * drifted `at` to optional, while the server always sends it.
+ */
+export type { ChannelHistoryEntry } from "@rebasepro/types";
+import type { ChannelHistoryEntry } from "@rebasepro/types";
 
 /** The answer to a catch-up request. */
 export interface ChannelHistoryResult {