@salesforce/webapp-experimental 1.21.0 → 1.22.0

package/dist/api/clients.d.ts

@@ -7,7 +7,7 @@ export declare const API_VERSION: string;
 declare class ApiClient {
     private readonly baseURL;
     private readonly defaultOptions;
-    constructor(baseURL: string, defaultOptions?: RequestInit);
+    constructor(baseURL: string);
     private isJsonContentType;
     private fetch;
     private processBody;
@@ -17,16 +17,6 @@ declare class ApiClient {
     patch(url: string, body?: unknown, options?: RequestInit): Promise<Response>;
     delete(url: string, options?: RequestInit): Promise<Response>;
 }
-export declare const baseClient: ApiClient;
-export declare const baseDataClient: ApiClient;
 export declare const uiApiClient: ApiClient;
-/**
- * Creates an ApiClient with the provided base URL and default options.
- *
- * @param baseURL - The base URL for the client
- * @param defaultOptions - Default RequestInit options
- * @returns A configured ApiClient
- */
-export declare function createClient(baseURL: string, defaultOptions?: RequestInit): ApiClient;
 export {};
 //# sourceMappingURL=clients.d.ts.map

package/dist/api/clients.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../src/api/clients.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,eAAO,MAAM,WAAW,QAA+B,CAAC;AAmBxD,cAAM,SAAS;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAc;gBAEjC,OAAO,EAAE,MAAM,EAAE,cAAc,GAAE,WAAgB;IAY7D,OAAO,CAAC,iBAAiB;YASX,KAAK;IAsBnB,OAAO,CAAC,WAAW;IAgBb,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQ/E,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAI9D,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQ9E,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQhF,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;CAGvE;AAGD,eAAO,MAAM,UAAU,WAAyB,CAAC;AAGjD,eAAO,MAAM,cAAc,WAA8B,CAAC;AAG1D,eAAO,MAAM,WAAW,WAA2B,CAAC;AAEpD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,GAAE,WAAgB,GAAG,SAAS,CAEzF"}
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../src/api/clients.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,eAAO,MAAM,WAAW,QAA+B,CAAC;AAQxD,cAAM,SAAS;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAK7B;gBAEU,OAAO,EAAE,MAAM;IAI3B,OAAO,CAAC,iBAAiB;YASX,KAAK;IAenB,OAAO,CAAC,WAAW;IAgBb,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQ/E,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAI9D,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQ9E,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQhF,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;CAGvE;AAGD,eAAO,MAAM,WAAW,WAA4B,CAAC"}

package/dist/api/clients.js

@@ -3,45 +3,31 @@
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-import { ConduitClient } from "@conduit-client/salesforce-lightning-service-worker";
-const BASE_URL = __SF_SERVER_BASE_PATH__ || "";
+import { sdk } from "@salesforce/sdk-data";
 // Project standard API version from environment variable with fallback
 export const API_VERSION = __SF_API_VERSION__ || "65.0";
-const BASE_SERVICES_URL = `${BASE_URL}/services`;
-const BASE_DATA_URL = `${BASE_SERVICES_URL}/data/v${API_VERSION}`;
+const BASE_DATA_URL = `/services/data/v${API_VERSION}`;
 const UI_API_URL = `${BASE_DATA_URL}/ui-api`;
-const TOKEN_ENDPOINT = `${UI_API_URL}/session/csrf`;
-const CACHE_VERSION = 1;
-const CACHE_NAME = `vibe-coding-starter-${CACHE_VERSION}`;
-ConduitClient.initialize({
-    csrf: {
-        endpoint: TOKEN_ENDPOINT,
-        cacheName: CACHE_NAME,
-        protectedUrls: ["/services/data/v", "/lwr/apex/v"],
-    },
-});
-const conduitClient = ConduitClient.instance();
+const MIME_TYPE_JSON = "application/json";
+const HEADER_CONTENT_TYPE = "Content-Type";
 class ApiClient {
     baseURL;
-    defaultOptions;
-    constructor(baseURL, defaultOptions = {}) {
+    defaultOptions = {
+        headers: {
+            [HEADER_CONTENT_TYPE]: MIME_TYPE_JSON,
+            Accept: MIME_TYPE_JSON,
+        },
+    };
+    constructor(baseURL) {
         this.baseURL = baseURL;
-        this.defaultOptions = {
-            ...defaultOptions,
-            headers: {
-                "Content-Type": "application/json",
-                Accept: "application/json",
-                ...(defaultOptions.headers || {}),
-            },
-        };
     }
     isJsonContentType(headers) {
         // default to JSON if no headers specified
         if (!headers)
             return true;
         const headersObj = new Headers(headers);
-        const contentType = headersObj.get("content-type");
-        return !contentType || contentType.includes("application/json");
+        const contentType = headersObj.get(HEADER_CONTENT_TYPE);
+        return !contentType || contentType.includes(MIME_TYPE_JSON);
     }
     async fetch(info, options = {}) {
         const fullURL = info instanceof URL || info.startsWith("http") ? info : `${this.baseURL}${info}`;
@@ -53,12 +39,7 @@ class ApiClient {
                 ...(options.headers || {}),
             },
         };
-        const response = await conduitClient.fetch(fullURL, mergedOptions);
-        // handle 401/403 with page reload
-        if (response.status === 401 || response.status === 403) {
-            window.location.reload();
-        }
-        return response;
+        return await sdk.fetch(fullURL, mergedOptions);
     }
     processBody(body, options) {
         if (body === undefined || body === null) {
@@ -77,45 +58,31 @@ class ApiClient {
     }
     async post(url, body, options = {}) {
         return this.fetch(url, {
+            ...options,
             method: "POST",
             body: this.processBody(body, options),
-            ...options,
         });
     }
     async get(url, options = {}) {
-        return this.fetch(url, { method: "GET", ...options });
+        return this.fetch(url, { ...options, method: "GET" });
     }
     async put(url, body, options = {}) {
         return this.fetch(url, {
+            ...options,
             method: "PUT",
             body: this.processBody(body, options),
-            ...options,
         });
     }
     async patch(url, body, options = {}) {
         return this.fetch(url, {
+            ...options,
             method: "PATCH",
             body: this.processBody(body, options),
-            ...options,
         });
     }
     async delete(url, options = {}) {
-        return this.fetch(url, { method: "DELETE", ...options });
+        return this.fetch(url, { ...options, method: "DELETE" });
     }
 }
-// Base fetch client
-export const baseClient = createClient(BASE_URL);
-// Extension of the base client that by default points to this project's standard version of the Salesforce API
-export const baseDataClient = createClient(BASE_DATA_URL);
 // Client for Salesforce UI API access
-export const uiApiClient = createClient(UI_API_URL);
-/**
- * Creates an ApiClient with the provided base URL and default options.
- *
- * @param baseURL - The base URL for the client
- * @param defaultOptions - Default RequestInit options
- * @returns A configured ApiClient
- */
-export function createClient(baseURL, defaultOptions = {}) {
-    return new ApiClient(baseURL, defaultOptions);
-}
+export const uiApiClient = new ApiClient(UI_API_URL);

package/dist/api/clients.test.js

@@ -3,18 +3,17 @@
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-// @vitest-environment jsdom
-import { ConduitClient } from "@conduit-client/salesforce-lightning-service-worker";
+import { sdk } from "@salesforce/sdk-data";
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createClient, baseClient, baseDataClient, uiApiClient } from "./clients.js";
-vi.mock("@conduit-client/salesforce-lightning-service-worker", () => {
+import { uiApiClient } from "./clients.js";
+vi.mock("@salesforce/sdk-data", () => {
     return {
-        ConduitClient: {
-            initialize: vi.fn(),
-            instance: vi.fn().mockReturnValue({ fetch: vi.fn() }),
+        sdk: {
+            fetch: vi.fn(),
         },
     };
 });
+vi.stubGlobal("window", {});
 // Mock window.location.reload
 const mockReload = vi.fn();
 Object.defineProperty(window, "location", {
@@ -24,219 +23,145 @@ Object.defineProperty(window, "location", {
 describe("clients", () => {
     let mockFetch;
     beforeEach(() => {
-        const mockClient = vi.mocked(ConduitClient.instance());
-        mockFetch = mockClient.fetch;
+        mockFetch = vi.mocked(sdk.fetch);
         mockFetch.mockClear();
         mockReload.mockClear();
     });
     afterEach(() => {
         vi.clearAllMocks();
     });
-    it("should have configured ConduitClient", () => {
-        expect(ConduitClient.initialize).toHaveBeenCalledWith({
-            csrf: {
-                endpoint: "/services/data/v99.0/ui-api/session/csrf",
-                cacheName: "vibe-coding-starter-1",
-                protectedUrls: ["/services/data/v", "/lwr/apex/v"],
-            },
-        });
-    });
-    describe("constructor and default options", () => {
-        it("should create client with default JSON headers", () => {
-            const client = createClient("/api");
-            expect(client).toBeDefined();
-        });
+    describe("uiApiClient", () => {
         it("should merge custom headers with defaults", async () => {
-            const client = createClient("/api", {
-                headers: { "Custom-Header": "value" },
-            });
             mockFetch.mockResolvedValueOnce({
                 status: 200,
                 json: () => Promise.resolve({ success: true }),
             });
-            await client.get("/test");
-            expect(mockFetch).toHaveBeenCalledWith("/api/test", {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                    "Custom-Header": "value",
-                },
-            });
-        });
-    });
-    describe("URL construction", () => {
-        it("should combine base URL with relative paths", async () => {
-            const client = createClient("/api/v1");
-            mockFetch.mockResolvedValueOnce({
-                status: 200,
-                json: () => Promise.resolve({}),
-            });
-            await client.get("/users");
-            expect(mockFetch).toHaveBeenCalledWith("/api/v1/users", expect.any(Object));
-        });
-        it("should use absolute URLs as-is", async () => {
-            const client = createClient("/api");
-            mockFetch.mockResolvedValueOnce({
-                status: 200,
-                json: () => Promise.resolve({}),
-            });
-            await client.get("https://external.com/data");
-            expect(mockFetch).toHaveBeenCalledWith("https://external.com/data", expect.any(Object));
-        });
-    });
-    describe("HTTP methods", () => {
-        let client;
-        beforeEach(() => {
-            client = createClient("/api");
-            mockFetch.mockResolvedValue({
-                status: 200,
-                json: () => Promise.resolve({ success: true }),
+            await uiApiClient.get("/test", {
+                headers: { "Custom-Header": "value" },
             });
-        });
-        it("should make GET requests", async () => {
-            await client.get("/users");
-            expect(mockFetch).toHaveBeenCalledWith("/api/users", {
+            expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/test", {
                 method: "GET",
                 headers: {
                     "Content-Type": "application/json",
                     Accept: "application/json",
+                    "Custom-Header": "value",
                 },
             });
         });
-        it("should make POST requests with JSON body", async () => {
-            const data = { name: "John" };
-            await client.post("/users", data);
-            expect(mockFetch).toHaveBeenCalledWith("/api/users", {
-                method: "POST",
-                body: JSON.stringify(data),
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                },
-            });
-        });
-        it("should make PUT requests with JSON body", async () => {
-            const data = { name: "John Updated" };
-            await client.put("/users/1", data);
-            expect(mockFetch).toHaveBeenCalledWith("/api/users/1", {
-                method: "PUT",
-                body: JSON.stringify(data),
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                },
-            });
-        });
-        it("should make PATCH requests with JSON body", async () => {
-            const data = { name: "John Patched" };
-            await client.patch("/users/1", data);
-            expect(mockFetch).toHaveBeenCalledWith("/api/users/1", {
-                method: "PATCH",
-                body: JSON.stringify(data),
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                },
-            });
-        });
-        it("should make DELETE requests", async () => {
-            await client.delete("/users/1");
-            expect(mockFetch).toHaveBeenCalledWith("/api/users/1", {
-                method: "DELETE",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                },
-            });
-        });
-    });
-    describe("body processing", () => {
-        let client;
-        beforeEach(() => {
-            client = createClient("/api");
-            mockFetch.mockResolvedValue({
-                status: 200,
-                json: () => Promise.resolve({}),
-            });
-        });
-        it("should stringify object bodies for JSON content-type", async () => {
-            const data = { name: "John" };
-            await client.post("/users", data);
-            expect(mockFetch).toHaveBeenCalledWith("/api/users", expect.objectContaining({
-                body: JSON.stringify(data),
-            }));
-        });
-        it("should not stringify non-object bodies", async () => {
-            const formData = new FormData();
-            await client.post("/upload", formData);
-            expect(mockFetch).toHaveBeenCalledWith("/api/upload", expect.objectContaining({
-                body: formData,
-            }));
-        });
-        it("should not stringify when content-type is not JSON", async () => {
-            const data = { name: "John" };
-            await client.post("/users", data, {
-                headers: { "Content-Type": "multipart/form-data" },
-            });
-            // When content-type is not JSON and body is a plain object (not FormData/string),
-            // processBody returns undefined since it can't serialize non-JSON content
-            expect(mockFetch).toHaveBeenCalledWith("/api/users", expect.objectContaining({
-                body: undefined,
-            }));
-        });
-    });
-    describe("error handling", () => {
-        let client;
-        beforeEach(() => {
-            client = createClient("/api");
-        });
-        it("should reload page on 401 status", async () => {
-            mockFetch.mockResolvedValueOnce({
-                status: 401,
-                json: () => Promise.resolve({}),
-            });
-            await client.get("/protected");
-            expect(mockReload).toHaveBeenCalled();
-        });
-        it("should reload page on 403 status", async () => {
-            mockFetch.mockResolvedValueOnce({
-                status: 403,
-                json: () => Promise.resolve({}),
-            });
-            await client.get("/protected");
-            expect(mockReload).toHaveBeenCalled();
-        });
-        it("should not reload page on other status codes", async () => {
-            mockFetch.mockResolvedValueOnce({
-                status: 404,
-                json: () => Promise.resolve({}),
-            });
-            await client.get("/notfound");
-            expect(mockReload).not.toHaveBeenCalled();
-        });
-    });
-    describe("exported clients", () => {
-        it("should export baseClient with correct base URL", () => {
-            expect(baseClient).toBeDefined();
-        });
-        it("should export baseDataClient with correct base URL", () => {
-            expect(baseDataClient).toBeDefined();
-        });
-        it("should export uiApiClient with correct base URL", () => {
-            expect(uiApiClient).toBeDefined();
-        });
-    });
-    describe("createClient factory", () => {
-        it("should create client with provided base URL", () => {
-            const client = createClient("/custom");
-            expect(client).toBeDefined();
-        });
-        it("should create client with default options", () => {
-            const client = createClient("/api", {
-                headers: { Authorization: "Bearer token" },
+        describe("URL construction", () => {
+            it("should combine base URL with relative paths", async () => {
+                mockFetch.mockResolvedValueOnce({
+                    status: 200,
+                    json: () => Promise.resolve({}),
+                });
+                await uiApiClient.get("/users");
+                expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/users", expect.any(Object));
+            });
+            it("should use absolute URLs as-is", async () => {
+                mockFetch.mockResolvedValueOnce({
+                    status: 200,
+                    json: () => Promise.resolve({}),
+                });
+                await uiApiClient.get("https://external.com/data");
+                expect(mockFetch).toHaveBeenCalledWith("https://external.com/data", expect.any(Object));
+            });
+        });
+        describe("HTTP methods", () => {
+            beforeEach(() => {
+                mockFetch.mockResolvedValue({
+                    status: 200,
+                    json: () => Promise.resolve({ success: true }),
+                });
+            });
+            it("should make GET requests", async () => {
+                await uiApiClient.get("/users");
+                expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/users", {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                    },
+                });
+            });
+            it("should make POST requests with JSON body", async () => {
+                const data = { name: "John" };
+                await uiApiClient.post("/users", data);
+                expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/users", {
+                    method: "POST",
+                    body: JSON.stringify(data),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                    },
+                });
+            });
+            it("should make PUT requests with JSON body", async () => {
+                const data = { name: "John Updated" };
+                await uiApiClient.put("/users/1", data);
+                expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/users/1", {
+                    method: "PUT",
+                    body: JSON.stringify(data),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                    },
+                });
+            });
+            it("should make PATCH requests with JSON body", async () => {
+                const data = { name: "John Patched" };
+                await uiApiClient.patch("/users/1", data);
+                expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/users/1", {
+                    method: "PATCH",
+                    body: JSON.stringify(data),
+                    headers: {
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                    },
+                });
+            });
+            it("should make DELETE requests", async () => {
+                await uiApiClient.delete("/users/1");
+                expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/users/1", {
+                    method: "DELETE",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                    },
+                });
+            });
+        });
+        describe("body processing", () => {
+            beforeEach(() => {
+                mockFetch.mockResolvedValue({
+                    status: 200,
+                    json: () => Promise.resolve({}),
+                });
+            });
+            it("should stringify object bodies for JSON content-type", async () => {
+                const data = { name: "John" };
+                await uiApiClient.post("/users", data);
+                expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/users", expect.objectContaining({
+                    body: JSON.stringify(data),
+                }));
+            });
+            it("should not stringify non-object bodies", async () => {
+                const formData = new FormData();
+                await uiApiClient.post("/upload", formData);
+                expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/upload", expect.objectContaining({
+                    body: formData,
+                }));
+            });
+            it("should not stringify when content-type is not JSON", async () => {
+                const data = { name: "John" };
+                await uiApiClient.post("/users", data, {
+                    headers: { "Content-Type": "multipart/form-data" },
+                });
+                // When content-type is not JSON and body is a plain object (not FormData/string),
+                // processBody returns undefined since it can't serialize non-JSON content
+                expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/ui-api/users", expect.objectContaining({
+                    body: undefined,
+                }));
             });
-            expect(client).toBeDefined();
         });
     });
 });