@rebasepro/client 0.17.3 → 0.18.0

package/src/storage.ts

@@ -1,253 +0,0 @@
-import { StorageSource, UploadFileProps, UploadFileResult, DownloadConfig, StorageListResult, DownloadMetadata, PUBLIC_STORAGE_PREFIX, isPublicStoragePath } from "@rebasepro/types";
-import { Transport } from "./transport";
-
-/**
- * Create a StorageSource that talks to the Rebase backend REST API.
- *
- * @param transport - HTTP transport instance
- * @param storageId - Optional storage-source key for multi-backend routing.
- *                    When set, it is forwarded to the server so the correct
- *                    `StorageController` is resolved from the registry.
- */
-/**
- * A storage key, encoded for a URL path.
- *
- * Every call below interpolated the key raw, and the server decodes what it
- * receives — so three ordinary filenames did three different wrong things:
- *
- *   `Invoice #12.pdf`  the `#` began the fragment, the server saw
- *                      `default/Invoice ` and looked up a key that is not the
- *                      file — and a scoped `?token=` after it was swallowed too
- *   `100% done.png`    `decodeURIComponent` threw URIError → 500
- *   `a%2Fb.png`        decoded to `a/b.png`, silently resolving a DIFFERENT
- *                      object
- *
- * Per SEGMENT, because `/` is the key's own separator and must survive; every
- * other character is encoded, including a literal `%`. Verified to round-trip
- * through the server's decode for all of the above, plus `+`, accented
- * characters and a trailing `%`.
- */
-export function encodeStorageKey(key: string): string {
-    return key.split("/").map(encodeURIComponent).join("/");
-}
-
-export function createStorage(transport: Transport, storageId?: string): StorageSource {
-    const urlsCache = new Map<string, { config: DownloadConfig; expiresAt?: number }>();
-
-    /**
-     * Base for URLs the *browser* will fetch on its own (file downloads,
-     * previews). API requests keep going to `baseUrl`; see
-     * {@link RebaseClientConfig.storageUrlOrigin} for why these can differ.
-     */
-    const fileUrlBase = (): string =>
-        `${transport.storageUrlOrigin ?? transport.baseUrl}${transport.apiPath}`;
-
-    /** Append ?storageId=... to a path when multi-backend routing is active. */
-    const withStorageId = (path: string): string => {
-        if (!storageId) return path;
-        const sep = path.includes("?") ? "&" : "?";
-        return `${path}${sep}storageId=${encodeURIComponent(storageId)}`;
-    };
-
-    async function putObject({
-        file,
-        key,
-        metadata,
-        bucket,
-        public: isPublic
-    }: UploadFileProps): Promise<UploadFileResult> {
-        const formData = new FormData();
-        formData.append("file", file);
-
-        // Public objects live under the public prefix so they can be served
-        // token-less via a stable, permanent URL. Normalize the key here so the
-        // stored path is self-describing (no server round-trip needed to know
-        // it's public).
-        let effectiveKey = key;
-        if (isPublic && effectiveKey && !isPublicStoragePath(effectiveKey)) {
-            effectiveKey = `${PUBLIC_STORAGE_PREFIX}${effectiveKey.replace(/^\/+/, "")}`;
-        }
-
-        if (effectiveKey) formData.append("key", effectiveKey);
-        if (bucket) formData.append("bucket", bucket);
-        if (storageId) formData.append("storageId", storageId);
-
-        if (metadata) {
-            for (const [key, value] of Object.entries(metadata)) {
-                if (value !== undefined && value !== null) {
-                    formData.append(
-                        `metadata_${key}`,
-                        typeof value === "string" ? value : JSON.stringify(value)
-                    );
-                }
-            }
-        }
-
-        const result = await transport.request<{ data: UploadFileResult }>(withStorageId("/storage/upload"), {
-            method: "POST",
-            body: formData,
-            headers: {}
-        });
-
-        return result.data;
-    }
-
-    async function getSignedUrl(
-        keyOrUrl: string,
-        bucket?: string
-    ): Promise<DownloadConfig> {
-        const cacheKey = bucket ? `${bucket}/${keyOrUrl}` : keyOrUrl;
-        const cachedEntry = urlsCache.get(cacheKey);
-        if (cachedEntry) {
-            if (!cachedEntry.expiresAt || cachedEntry.expiresAt > Date.now()) {
-                return cachedEntry.config;
-            }
-            urlsCache.delete(cacheKey);
-        }
-
-        let filePath = keyOrUrl;
-
-        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) {
-            filePath = filePath.substring(filePath.indexOf("://") + 3);
-        }
-
-        if (bucket && filePath && !filePath.startsWith(bucket)) {
-            filePath = `${bucket}/${filePath}`;
-        }
-
-        if (!filePath || filePath.trim() === "" || filePath === "/") {
-            return { url: null, fileNotFound: true };
-        }
-
-        // ── Public objects ────────────────────────────────────────────────
-        // A public file (under the public prefix) is served token-less via a
-        // stable, permanent, CDN-cacheable URL. No metadata round-trip and no
-        // token are needed — build the URL directly and cache it forever.
-        if (isPublicStoragePath(filePath)) {
-            const publicConfig: DownloadConfig = {
-                url: withStorageId(`${fileUrlBase()}/storage/file/${encodeStorageKey(filePath)}`)
-            };
-            urlsCache.set(cacheKey, { config: publicConfig }); // no expiry
-            return publicConfig;
-        }
-
-        try {
-            const result = await transport.request<{ data: DownloadMetadata }>(withStorageId(`/storage/metadata/${encodeStorageKey(filePath)}`));
-
-            // Public object (server-confirmed): token-less permanent URL.
-            if (result.data.public) {
-                const publicConfig: DownloadConfig = {
-                    url: withStorageId(`${fileUrlBase()}/storage/file/${encodeStorageKey(filePath)}`),
-                    metadata: result.data
-                };
-                urlsCache.set(cacheKey, { config: publicConfig }); // no expiry
-                return publicConfig;
-            }
-
-            // Private object: use the short-lived, file-scoped download token
-            // minted by the server. We deliberately do NOT fall back to the
-            // caller's access token — a URL must never carry a full-privilege
-            // credential. If no scoped token is present the URL fails closed.
-            const scopedToken = result.data.token;
-            const tokenQuery = scopedToken ? `?token=${scopedToken}` : "";
-
-            const downloadConfig: DownloadConfig = {
-                // `withStorageId` picks `?` or `&` based on whether the token
-                // query is already present, so the URL stays valid even when
-                // there is no token.
-                url: withStorageId(`${fileUrlBase()}/storage/file/${encodeStorageKey(filePath)}${tokenQuery}`),
-                metadata: result.data
-            };
-
-            const expiresAt = result.data.tokenExpiresIn
-                ? Date.now() + (result.data.tokenExpiresIn - 10) * 1000 // subtract 10s buffer
-                : undefined;
-
-            urlsCache.set(cacheKey, { config: downloadConfig, expiresAt });
-            return downloadConfig;
-        } catch (e: unknown) {
-            if (e instanceof Error && "status" in e && (e as { status: number }).status === 404) {
-                return { url: null, fileNotFound: true };
-            }
-            throw e;
-        }
-    }
-
-    async function getObject(
-        key: string,
-        bucket?: string
-    ): Promise<File | null> {
-        const downloadConfig = await getSignedUrl(key, bucket);
-        if (downloadConfig.fileNotFound || !downloadConfig.url) {
-            return null;
-        }
-
-        // Fetch using the signed URL directly. Since the scoped token is in the ?token= query param,
-        // we explicitly omit any Authorization headers to prevent passing full access tokens to file serving routes.
-        const response = await transport.fetchFn(downloadConfig.url, {
-            headers: {}
-        });
-
-        if (response.status === 404) return null;
-        if (!response.ok) throw new Error("Failed to get file");
-
-        const blob = await response.blob();
-        const fileName = (bucket ? `${bucket}/${key}` : key).split("/").pop() || "file";
-        return new File([blob], fileName, { type: blob.type });
-    }
-
-    async function deleteObject(
-        key: string,
-        bucket?: string
-    ): Promise<void> {
-        let filePath = key;
-
-        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) {
-            filePath = filePath.substring(filePath.indexOf("://") + 3);
-        }
-
-        if (bucket && filePath && !filePath.startsWith(bucket)) {
-            filePath = `${bucket}/${filePath}`;
-        }
-
-        if (!filePath || filePath.trim() === "" || filePath === "/") {
-            return;
-        }
-
-        try {
-            await transport.request(withStorageId(`/storage/file/${encodeStorageKey(filePath)}`), { method: "DELETE" });
-        } catch (e: unknown) {
-            if (!(e instanceof Error && "status" in e && (e as { status: number }).status === 404)) throw e;
-        }
-
-        urlsCache.delete(bucket ? `${bucket}/${key}` : key);
-    }
-
-    async function listObjects(
-        prefix: string,
-        options?: {
-            bucket?: string;
-            maxResults?: number;
-            pageToken?: string;
-        }
-    ): Promise<StorageListResult> {
-        const params = new URLSearchParams();
-        if (prefix) params.set("prefix", prefix);
-        if (options?.bucket) params.set("bucket", options.bucket);
-        if (options?.maxResults) params.set("maxResults", String(options.maxResults));
-        if (options?.pageToken) params.set("pageToken", options.pageToken);
-
-        if (storageId) params.set("storageId", storageId);
-
-        const result = await transport.request<{ data: StorageListResult }>(`/storage/list?${params.toString()}`);
-        return result.data;
-    }
-
-    return {
-        putObject,
-        getSignedUrl,
-        getObject,
-        deleteObject,
-        listObjects
-    };
-}

package/src/transport-baseurl.test.ts

@@ -1,101 +0,0 @@
-import { describe, it, expect, afterEach, jest } from "@jest/globals";
-import { createTransport } from "./transport";
-
-/**
- * `baseUrl` is optional because the common production shape is a Rebase backend
- * serving its own SPA: the API is the page's origin. These pin the resolution,
- * because getting it wrong pushes apps into baking an absolute host — which
- * breaks the moment a custom domain points at the same app, and which CORS
- * cannot repair (a SameSite=Lax auth cookie is not sent cross-site either).
- */
-const setWindow = (origin?: string) => {
-    if (origin === undefined) { delete (globalThis as never as { window?: unknown }).window; return; }
-    (globalThis as never as { window: unknown }).window = { location: { origin, href: origin + "/" } };
-};
-
-afterEach(() => setWindow(undefined));
-
-describe("transport baseUrl resolution", () => {
-    it("uses the page origin when unset in a browser", () => {
-        setWindow("https://dadaki.com");
-        expect(createTransport({}).baseUrl).toBe("https://dadaki.com");
-    });
-
-    it("gives callers something they can build an absolute URL from", () => {
-        setWindow("https://dadaki.com");
-        const t = createTransport({});
-        // The empty-string version of this threw, which is what drove apps to
-        // bake a hostname into the bundle.
-        expect(() => new URL(`${t.baseUrl}/api/functions/doc-content/get`)).not.toThrow();
-    });
-
-    it("follows the page, so a second hostname on the same app just works", () => {
-        setWindow("https://dadaki.rebase.website");
-        expect(createTransport({}).baseUrl).toBe("https://dadaki.rebase.website");
-        setWindow("https://dadaki.com");
-        expect(createTransport({}).baseUrl).toBe("https://dadaki.com");
-    });
-
-    it("still honours an explicit baseUrl, which is what dev needs", () => {
-        setWindow("https://dadaki.com");
-        expect(createTransport({ baseUrl: "http://localhost:3001" }).baseUrl).toBe("http://localhost:3001");
-    });
-
-    it("strips a trailing slash so joins do not double up", () => {
-        setWindow(undefined);
-        expect(createTransport({ baseUrl: "https://api.example.com/" }).baseUrl).toBe("https://api.example.com");
-    });
-
-    it("stays relative off-browser, where there is no origin to borrow", () => {
-        setWindow(undefined);
-        expect(createTransport({}).baseUrl).toBe("");
-    });
-});
-
-describe("baseUrl that already contains the apiPath", () => {
-    /**
-     * The docblock on `baseUrl` says this "silently builds `/api/api/…` and
-     * every request 404s" — a failure mode understood well enough to be written
-     * down, and still left to be discovered at runtime. This package's own
-     * tests configured it that way a dozen times over, which is about as clear
-     * a signal as a trap gets.
-     */
-    it("warns rather than silently building /api/api", () => {
-        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
-        createTransport({ baseUrl: "http://localhost:3000/api" });
-
-        expect(warn).toHaveBeenCalledWith(expect.stringContaining("/api/api"));
-        warn.mockRestore();
-    });
-
-    it("warns for a custom apiPath too, and tolerates a trailing slash", () => {
-        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
-        createTransport({ baseUrl: "https://api.example.com/v2/", apiPath: "/v2" });
-
-        expect(warn).toHaveBeenCalledTimes(1);
-        warn.mockRestore();
-    });
-
-    it("says nothing about a baseUrl that merely ends in a similar word", () => {
-        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
-        createTransport({ baseUrl: "https://rapid.example.com" });
-        createTransport({ baseUrl: "https://example.com/myapi" });
-        createTransport({ baseUrl: "https://example.com" });
-
-        expect(warn).not.toHaveBeenCalled();
-        warn.mockRestore();
-    });
-});
-
-describe("storageUrlOrigin that already contains the apiPath", () => {
-    it("warns, because storage composes it the same way baseUrl is composed", () => {
-        const warn = jest.spyOn(console, "warn").mockImplementation(() => {});
-        createTransport({
-            baseUrl: "https://example.com",
-            storageUrlOrigin: "https://files.example.com/api"
-        });
-
-        expect(warn).toHaveBeenCalledWith(expect.stringContaining("storageUrlOrigin"));
-        warn.mockRestore();
-    });
-});