@rebasepro/client 0.17.3-canary.gdd23447 → 0.18.0

package/src/api-keys.ts

@@ -1,87 +0,0 @@
-import type { Transport } from "./transport";
-
-/**
- * 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";
-
-import type {
-    ApiKeyMasked,
-    ApiKeyWithSecret,
-    CreateApiKeyRequest,
-    UpdateApiKeyRequest
-} from "@rebasepro/types";
-
-/** 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-listener-errors.test.ts

@@ -1,57 +0,0 @@
-import { jest } from "@jest/globals";
-import { createAuth } from "./auth";
-import type { Transport } from "./transport";
-
-/**
- * What happens to an error thrown by the app's own auth listener.
- *
- * `emit` isolates listeners from each other, which is right — one bad handler
- * must not stop the rest from being told about a sign-in. It also discarded the
- * error entirely, which is not: the throw came from the *caller's* code, and it
- * vanished with nothing in the console, so a broken `onAuthStateChange` handler
- * looked like an event that never fired.
- *
- * The socket in this same package already reports these
- * ("Error in channel handler:"). This was the one listener loop that did not.
- */
-function transport(): Transport {
-    return {
-        request: jest.fn<any>().mockResolvedValue({}),
-        setToken: jest.fn(),
-        setAuthTokenGetter: jest.fn(),
-        setOnUnauthorized: jest.fn(),
-        baseUrl: "http://localhost:3000",
-        apiPath: "/api",
-        fetchFn: globalThis.fetch,
-        getHeaders: () => ({}),
-        resolveToken: jest.fn<any>().mockResolvedValue(null)
-    } as unknown as Transport;
-}
-
-describe("auth state listeners", () => {
-    let error: ReturnType<typeof jest.spyOn>;
-
-    beforeEach(() => { error = jest.spyOn(console, "error").mockImplementation(() => { /* quiet */ }); });
-    afterEach(() => error.mockRestore());
-
-    it("keeps telling the other listeners when one throws", () => {
-        const auth = createAuth(transport());
-        const second = jest.fn();
-
-        auth.onAuthStateChange(() => { throw new Error("handler blew up"); });
-        auth.onAuthStateChange(second);
-        auth.signOut();
-
-        expect(second).toHaveBeenCalled();
-    });
-
-    it("reports the throw instead of discarding it", () => {
-        const auth = createAuth(transport());
-        auth.onAuthStateChange(() => { throw new Error("handler blew up"); });
-
-        auth.signOut();
-
-        const said = error.mock.calls.map((c: unknown[]) => c.map(String).join(" ")).join("\n");
-        expect(said).toMatch(/handler blew up/);
-    });
-});

package/src/auth-refresh-overflow.test.ts

@@ -1,89 +0,0 @@
-import { jest } from "@jest/globals";
-import { createAuth, createMemoryStorage } from "./auth";
-import type { Transport } from "./transport";
-
-/**
- * How far ahead the token refresh is allowed to be scheduled.
- *
- * `scheduleRefresh` computes `(expiresAt - REFRESH_BUFFER_MS) - Date.now()` and
- * hands it to `setTimeout`, with a floor for the past and no ceiling. Node and
- * every browser store that delay in a **32-bit signed integer**: hand them more
- * than 2,147,483,647 ms — about 24.8 days — and the timer does not wait, it
- * clamps to 1 ms and fires immediately.
- *
- * `auth.accessExpiresIn` is configurable and defaults to `"1h"`, so this is
- * dormant on a default deployment. Set it to `"30d"` — an ordinary choice for an
- * internal tool or a kiosk — and every signed-in browser refreshes at once,
- * receives a token expiring another 30 days out, schedules again, overflows
- * again: a hot loop against `/auth/refresh`, one per open tab.
- *
- * A floor without a ceiling is the tell. Someone already knew the input was
- * untrusted and bounded one side of it. (Class 23.)
- */
-const MAX_DELAY = 2_147_483_647;
-
-function transport(): Transport {
-    return {
-        request: jest.fn<any>().mockResolvedValue({}),
-        setToken: jest.fn(),
-        setAuthTokenGetter: jest.fn(),
-        setOnUnauthorized: jest.fn(),
-        baseUrl: "http://localhost:3000",
-        apiPath: "/api",
-        fetchFn: jest.fn<any>().mockResolvedValue({ ok: true, status: 200, json: async () => ({}) }),
-        getHeaders: () => ({}),
-        resolveToken: jest.fn<any>().mockResolvedValue(null)
-    } as unknown as Transport;
-}
-
-/** Storage already holding a session expiring `days` from now. */
-function storageWithSession(days: number) {
-    const storage = createMemoryStorage();
-    storage.setItem("rebase_auth", JSON.stringify({
-        accessToken: "at",
-        refreshToken: "rt",
-        expiresAt: Date.now() + days * 24 * 60 * 60 * 1000,
-        user: { uid: "u1" }
-    }));
-    return storage;
-}
-
-describe("scheduled token refresh", () => {
-    let delays: number[];
-    let realSetTimeout: typeof setTimeout;
-
-    beforeEach(() => {
-        delays = [];
-        realSetTimeout = globalThis.setTimeout;
-        globalThis.setTimeout = ((fn: () => void, ms?: number) => {
-            if (typeof ms === "number") delays.push(ms);
-            return realSetTimeout(() => { /* never run in this test */ }, 0);
-        }) as unknown as typeof setTimeout;
-    });
-
-    afterEach(() => { globalThis.setTimeout = realSetTimeout; });
-
-    it("schedules a normal one-hour token in the ordinary way", () => {
-        createAuth(transport(), { storage: storageWithSession(1 / 24) });
-
-        const scheduled = delays.filter(d => d > 1000);
-        expect(scheduled.length).toBeGreaterThan(0);
-        expect(Math.max(...scheduled)).toBeLessThanOrEqual(MAX_DELAY);
-    });
-
-    it("never asks setTimeout for a delay it cannot hold", () => {
-        // 30 days: 2,592,000,000 ms, past the 32-bit ceiling.
-        createAuth(transport(), { storage: storageWithSession(30) });
-
-        for (const d of delays) expect(d).toBeLessThanOrEqual(MAX_DELAY);
-    });
-
-    it("does not schedule a refresh for one millisecond from now", () => {
-        // The symptom of the overflow: the clamp makes it immediate, and the
-        // refresh that follows schedules another one just as far out.
-        createAuth(transport(), { storage: storageWithSession(90) });
-
-        const immediate = delays.filter(d => d > 0 && d < 1000);
-        expect(immediate).toEqual([]);
-    });
-});