@rebasepro/client 0.7.0 → 0.8.0

package/src/storage.ts

@@ -1,13 +1,23 @@
 import { StorageSource, UploadFileProps, UploadFileResult, DownloadConfig, StorageListResult, DownloadMetadata } from "@rebasepro/types";
 import { Transport } from "./transport";
 
-export function createStorage(transport: Transport): StorageSource {
+/**
+ * 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.
+ */
+export function createStorage(transport: Transport, storageId?: string): StorageSource {
     const urlsCache = new Map<string, DownloadConfig>();
 
-    // We expect the transport to point to /api, and storage endpoints handle /api/storage internally if they are relative?
-    // Wait, useBackendStorageSource uses `${apiUrl}/api/storage` directly.
-    // Transport has `.request` which hits `${config.baseUrl}${config.apiPath}${path}`.
-    // Assuming `config.apiPath` is "/api", we just request(`/storage/upload`, ...).
+    /** 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,
@@ -20,6 +30,7 @@ export function createStorage(transport: Transport): StorageSource {
 
         if (key) formData.append("key", key);
         if (bucket) formData.append("bucket", bucket);
+        if (storageId) formData.append("storageId", storageId);
 
         if (metadata) {
             for (const [key, value] of Object.entries(metadata)) {
@@ -32,16 +43,10 @@ export function createStorage(transport: Transport): StorageSource {
             }
         }
 
-        // We use fetchFn directly if we need to do multipart boundary, but Transport.request might override Content-Type?
-        // Wait, transport.request defaults to application/json. We must remove Content-Type header or allow it to be evaluated by fetch when body is FormData!
-        const result = await transport.request<{ data: UploadFileResult }>("/storage/upload", {
+        const result = await transport.request<{ data: UploadFileResult }>(withStorageId("/storage/upload"), {
             method: "POST",
             body: formData,
-            headers: {
-                // transport.request merges headers, so to prevent it setting application/json we can delete it
-                // in transport if body is FormData, or we can explicitly set it to an empty string.
-                // Let's rely on standard behaviour for now and adjust transport if it fails.
-            }
+            headers: {}
         });
 
         return result.data;
@@ -57,7 +62,7 @@ export function createStorage(transport: Transport): StorageSource {
 
         let filePath = keyOrUrl;
 
-        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
+        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) {
             filePath = filePath.substring(filePath.indexOf("://") + 3);
         }
 
@@ -71,13 +76,16 @@ fileNotFound: true };
         }
 
         try {
-            const result = await transport.request<{ data: DownloadMetadata }>(`/storage/metadata/${filePath}`);
+            const result = await transport.request<{ data: DownloadMetadata }>(withStorageId(`/storage/metadata/${filePath}`));
 
             const activeToken = await transport.resolveToken();
             const tokenQuery = activeToken ? `?token=${activeToken}` : "";
 
             const downloadConfig: DownloadConfig = {
-                url: `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`,
+                // `withStorageId` picks `?` or `&` based on whether the token
+                // query is already present, so the URL stays valid even when
+                // there is no auth token.
+                url: withStorageId(`${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`),
                 metadata: result.data
             };
 
@@ -98,7 +106,7 @@ fileNotFound: true };
     ): Promise<File | null> {
         let filePath = key;
 
-        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
+        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) {
             filePath = filePath.substring(filePath.indexOf("://") + 3);
         }
 
@@ -111,7 +119,7 @@ fileNotFound: true };
         }
 
         // We must use plain fetch because transport.request expects JSON response, but here we want a Blob.
-        const url = `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`;
+        const url = withStorageId(`${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`);
 
         // This is a bit manual, but necessary for blob handling
         const response = await transport.fetchFn(url, {
@@ -132,7 +140,7 @@ fileNotFound: true };
     ): Promise<void> {
         let filePath = key;
 
-        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
+        if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://") || filePath.startsWith("gs://"))) {
             filePath = filePath.substring(filePath.indexOf("://") + 3);
         }
 
@@ -145,7 +153,7 @@ fileNotFound: true };
         }
 
         try {
-            await transport.request(`/storage/file/${filePath}`, { method: "DELETE" });
+            await transport.request(withStorageId(`/storage/file/${filePath}`), { method: "DELETE" });
         } catch (e: unknown) {
             if (!(e instanceof Error && "status" in e && (e as { status: number }).status === 404)) throw e;
         }
@@ -167,6 +175,8 @@ fileNotFound: true };
         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;
     }

package/src/transport.ts

@@ -1,4 +1,5 @@
-import { FindParams as TypesFindParams, FindResponse as TypesFindResponse, WhereFieldValue, WhereFilterOpShort } from "@rebasepro/types";
+import { FindParams as TypesFindParams, FindResponse as TypesFindResponse } from "@rebasepro/types";
+import { serializeFilter, serializeLogicalCondition } from "@rebasepro/common";
 import { rebaseReviver } from "./reviver";
 
 export interface RebaseClientConfig {
@@ -30,80 +31,6 @@ export class RebaseApiError extends Error {
     }
 }
 
-/**
- * Maps a short operator alias to the PostgREST-style short code.
- */
-const OP_MAP: Record<string, string> = {
-    "==": "eq",
-"!=": "neq",
-    ">": "gt",
-">=": "gte",
-    "<": "lt",
-"<=": "lte",
-    "not-in": "nin",
-    "array-contains": "cs",
-    "array-contains-any": "csa"
-};
-
-/**
- * Normalise a single `WhereFieldValue` into the PostgREST query-string
- * representation the backend expects.
- *
- * Supports:
- *  - `null`          → `"eq.null"`
- *  - `true`/`false`  → `"eq.true"` / `"eq.false"`
- *  - `42`            → `"42"` (plain equality)
- *  - `"active"`      → `"active"` (plain equality, backward-compat)
- *  - `"gte.18"`      → `"gte.18"` (pass-through PostgREST string)
- *  - `[">=", 18]`    → `"gte.18"` (tuple syntax)
- *  - `["in", [1,2]]` → `"in.(1,2)"` (tuple with array value)
- *  - `["!=", null]`  → `"neq.null"`
- */
-function normalizeWhereValue(value: WhereFieldValue): string {
-    // Null → eq.null
-    if (value === null) return "eq.null";
-
-    // Boolean → eq.true / eq.false
-    if (typeof value === "boolean") return `eq.${value}`;
-
-    // Number → plain equality
-    if (typeof value === "number") return String(value);
-
-    // Tuple: [operator, val]
-    if (Array.isArray(value)) {
-        const conditions: [WhereFilterOpShort, any][] = Array.isArray(value[0])
-            ? (value as [WhereFilterOpShort, any][])
-            : [value as [WhereFilterOpShort, any]];
-
-        const [rawOp, val] = conditions[0] || [];
-        if (rawOp) {
-            const op = OP_MAP[rawOp] ?? rawOp;
-            if (val === null) return `${op}.null`;
-            if (Array.isArray(val)) return `${op}.(${val.join(",")})`;
-            return `${op}.${val}`;
-        }
-    }
-
-    // String — pass through (either plain equality value or PostgREST syntax)
-    return String(value);
-}
-
-function serializeLogicalCondition(cond: any): string {
-    if ("type" in cond) {
-        const sub = (cond.conditions ?? []).map(serializeLogicalCondition).join(",");
-        return `${cond.type}(${sub})`;
-    } else {
-        const op = OP_MAP[cond.operator] ?? cond.operator;
-        let formattedValue = cond.value;
-        if (Array.isArray(cond.value)) {
-            formattedValue = `(${cond.value.join(",")})`;
-        } else if (cond.value === null) {
-            formattedValue = "null";
-        }
-        return `${cond.column}.${op}.${formattedValue}`;
-    }
-}
-
 export function buildQueryString(params?: FindParams): string {
     if (!params) return "";
     const parts: string[] = [];
@@ -131,15 +58,14 @@ export function buildQueryString(params?: FindParams): string {
     }
 
     if (params.where) {
-        for (const [field, value] of Object.entries(params.where)) {
-            if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) {
-                for (const subVal of value) {
-                    const normalized = normalizeWhereValue(subVal as WhereFieldValue);
-                    parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+        const serialized = serializeFilter(params.where);
+        for (const [field, value] of Object.entries(serialized)) {
+            if (Array.isArray(value)) {
+                for (const v of value) {
+                    parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(v)}`);
                 }
             } else {
-                const normalized = normalizeWhereValue(value as WhereFieldValue);
-                parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+                parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(value)}`);
             }
         }
     }