@salesforce/webapp-experimental 0.2.0

package/README.md

@@ -0,0 +1,3 @@
+# @salesforce/webapp-experimental
+
+Core package for Salesforce Web Applications

package/dist/api/apex.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Client for querying or mutating data via an Apex class methods that have
+ * been annotated as @AuraEnabled
+ */
+export declare const apexClient: {
+    get: (className: string, methodName: string, params?: Record<string, unknown>) => Promise<unknown>;
+    post: (className: string, methodName: string, params?: Record<string, unknown>) => Promise<unknown>;
+};
+//# sourceMappingURL=apex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apex.d.ts","sourceRoot":"","sources":["../../src/api/apex.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,eAAO,MAAM,UAAU;qBACL,MAAM,cAAc,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;sBAG3D,MAAM,cAAc,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG9E,CAAC"}

package/dist/api/apex.js

@@ -0,0 +1,18 @@
+import { API_VERSION, createClient } from "./clients.js";
+const client = createClient(`/lwr/apex/v${API_VERSION}`);
+/**
+ * Client for querying or mutating data via an Apex class methods that have
+ * been annotated as @AuraEnabled
+ */
+export const apexClient = {
+    get: (className, methodName, params) => {
+        return executeApex("get", className, methodName, params);
+    },
+    post: (className, methodName, params) => {
+        return executeApex("post", className, methodName, params);
+    },
+};
+async function executeApex(method, className, methodName, params) {
+    const res = await client[method](`/${className}/${methodName}`, params);
+    return await res.json();
+}

package/dist/api/apex.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=apex.test.d.ts.map

package/dist/api/apex.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apex.test.d.ts","sourceRoot":"","sources":["../../src/api/apex.test.ts"],"names":[],"mappings":""}

package/dist/api/apex.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { apexClient } from "./apex.js";
+import { createClient } from "./clients.js";
+vi.mock("./clients.js", () => ({
+    API_VERSION: "65.0",
+    createClient: vi.fn().mockReturnValue({
+        get: vi.fn(),
+        post: vi.fn(),
+    }),
+}));
+describe("apexClient", () => {
+    let mockClient;
+    let mockResponse;
+    beforeEach(async () => {
+        mockResponse = {
+            json: vi.fn(),
+        };
+        mockClient = vi.mocked(createClient).mock.results[0].value;
+        mockClient.get.mockResolvedValue(mockResponse);
+        mockClient.post.mockResolvedValue(mockResponse);
+        vi.mocked(createClient).mockReturnValue(mockClient);
+    });
+    afterEach(() => {
+        mockClient.get.mockClear();
+        mockClient.post.mockClear();
+    });
+    describe("get", () => {
+        it("should pass parameters to GET request", async () => {
+            const params = { id: "123", name: "test" };
+            const mockData = { result: "success" };
+            mockResponse.json.mockResolvedValue(mockData);
+            const result = await apexClient.get("TestClass", "testMethod", params);
+            expect(mockClient.get).toHaveBeenCalledWith("/TestClass/testMethod", params);
+            expect(result).toEqual(mockData);
+        });
+        it("should handle empty parameters", async () => {
+            const mockData = { result: "success" };
+            mockResponse.json.mockResolvedValue(mockData);
+            const result = await apexClient.get("TestClass", "testMethod", {});
+            expect(mockClient.get).toHaveBeenCalledWith("/TestClass/testMethod", {});
+            expect(result).toEqual(mockData);
+        });
+    });
+    describe("post", () => {
+        it("should pass parameters to POST request", async () => {
+            const params = { name: "new item", value: 42 };
+            const mockData = { id: "abc123", result: "created" };
+            mockResponse.json.mockResolvedValue(mockData);
+            const result = await apexClient.post("TestClass", "createMethod", params);
+            expect(mockClient.post).toHaveBeenCalledWith("/TestClass/createMethod", params);
+            expect(result).toEqual(mockData);
+        });
+        it("should handle empty parameters", async () => {
+            const mockData = { result: "success" };
+            mockResponse.json.mockResolvedValue(mockData);
+            const result = await apexClient.post("TestClass", "testMethod", {});
+            expect(mockClient.post).toHaveBeenCalledWith("/TestClass/testMethod", {});
+            expect(result).toEqual(mockData);
+        });
+    });
+});

package/dist/api/clients.d.ts

@@ -0,0 +1,27 @@
+export declare const API_VERSION: string;
+declare class ApiClient {
+    private readonly baseURL;
+    private readonly defaultOptions;
+    constructor(baseURL: string, defaultOptions?: RequestInit);
+    private isJsonContentType;
+    private fetch;
+    private processBody;
+    post(url: string, body?: unknown, options?: RequestInit): Promise<Response>;
+    get(url: string, options?: RequestInit): Promise<Response>;
+    put(url: string, body?: unknown, options?: RequestInit): Promise<Response>;
+    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

@@ -0,0 +1 @@
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../src/api/clients.ts"],"names":[],"mappings":"AAQA,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"}

package/dist/api/clients.js

@@ -0,0 +1,116 @@
+import { ConduitClient } from "@conduit-client/salesforce-lightning-service-worker";
+const BASE_URL = __SF_SERVER_BASE_PATH__ || "";
+// 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 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();
+class ApiClient {
+    baseURL;
+    defaultOptions;
+    constructor(baseURL, defaultOptions = {}) {
+        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");
+    }
+    async fetch(info, options = {}) {
+        const fullURL = info instanceof URL || info.startsWith("http") ? info : `${this.baseURL}${info}`;
+        const mergedOptions = {
+            ...this.defaultOptions,
+            ...options,
+            headers: {
+                ...this.defaultOptions.headers,
+                ...(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;
+    }
+    processBody(body, options) {
+        if (body === undefined || body === null) {
+            return undefined;
+        }
+        if (body instanceof FormData) {
+            return body;
+        }
+        if (typeof body === "string") {
+            return body;
+        }
+        if (typeof body === "object" && this.isJsonContentType(options.headers)) {
+            return JSON.stringify(body);
+        }
+        return undefined;
+    }
+    async post(url, body, options = {}) {
+        return this.fetch(url, {
+            method: "POST",
+            body: this.processBody(body, options),
+            ...options,
+        });
+    }
+    async get(url, options = {}) {
+        return this.fetch(url, { method: "GET", ...options });
+    }
+    async put(url, body, options = {}) {
+        return this.fetch(url, {
+            method: "PUT",
+            body: this.processBody(body, options),
+            ...options,
+        });
+    }
+    async patch(url, body, options = {}) {
+        return this.fetch(url, {
+            method: "PATCH",
+            body: this.processBody(body, options),
+            ...options,
+        });
+    }
+    async delete(url, options = {}) {
+        return this.fetch(url, { method: "DELETE", ...options });
+    }
+}
+// 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);
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=clients.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clients.test.d.ts","sourceRoot":"","sources":["../../src/api/clients.test.ts"],"names":[],"mappings":""}

package/dist/api/clients.test.js

@@ -0,0 +1,237 @@
+// @vitest-environment jsdom
+import { ConduitClient } from "@conduit-client/salesforce-lightning-service-worker";
+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", () => {
+    return {
+        ConduitClient: {
+            initialize: vi.fn(),
+            instance: vi.fn().mockReturnValue({ fetch: vi.fn() }),
+        },
+    };
+});
+// Mock window.location.reload
+const mockReload = vi.fn();
+Object.defineProperty(window, "location", {
+    value: { reload: mockReload },
+    writable: true,
+});
+describe("clients", () => {
+    let mockFetch;
+    beforeEach(() => {
+        const mockClient = vi.mocked(ConduitClient.instance());
+        mockFetch = mockClient.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();
+        });
+        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 }),
+            });
+        });
+        it("should make GET requests", async () => {
+            await client.get("/users");
+            expect(mockFetch).toHaveBeenCalledWith("/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 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" },
+            });
+            expect(client).toBeDefined();
+        });
+    });
+});

package/dist/api/graphql.d.ts

@@ -0,0 +1,20 @@
+export interface GraphQLResponse<T> {
+    data: T;
+    errors?: {
+        message: string;
+        locations?: {
+            line: number;
+            column: number;
+        }[];
+        path?: string[];
+    }[];
+}
+/**
+ * Execute a GraphQL query against the Salesforce GraphQL API
+ *
+ * @param query - The GraphQL query string
+ * @param variables - Optional variables for the query
+ * @returns The GraphQL response data
+ */
+export declare function executeGraphQL<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
+//# sourceMappingURL=graphql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/api/graphql.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,eAAe,CAAC,CAAC;IACjC,IAAI,EAAE,CAAC,CAAC;IACR,MAAM,CAAC,EAAE;QACR,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAC/C,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;KAChB,EAAE,CAAC;CACJ;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACrC,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,CAAC,CAAC,CAaZ"}

package/dist/api/graphql.js

@@ -0,0 +1,20 @@
+import { baseDataClient } from "./clients.js";
+/**
+ * Execute a GraphQL query against the Salesforce GraphQL API
+ *
+ * @param query - The GraphQL query string
+ * @param variables - Optional variables for the query
+ * @returns The GraphQL response data
+ */
+export async function executeGraphQL(query, variables) {
+    const res = await baseDataClient.post("/graphql", {
+        query,
+        variables,
+    });
+    const json = await res.json();
+    if (json.errors?.length) {
+        const errorMessages = json.errors.map((e) => e.message).join("; ");
+        throw new Error(`GraphQL Error: ${errorMessages}`);
+    }
+    return json.data;
+}

package/dist/api/graphql.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=graphql.test.d.ts.map

package/dist/api/graphql.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.test.d.ts","sourceRoot":"","sources":["../../src/api/graphql.test.ts"],"names":[],"mappings":""}

package/dist/api/graphql.test.js

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { baseDataClient } from "./clients.js";
+import { executeGraphQL } from "./graphql.js";
+vi.mock("./clients.js", () => ({
+    baseDataClient: {
+        post: vi.fn(),
+    },
+}));
+describe("executeGraphQL", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should successfully execute a GraphQL query", async () => {
+        const mockData = {
+            uiapi: {
+                query: {
+                    Account: {
+                        edges: [
+                            {
+                                node: {
+                                    Id: "001",
+                                    Name: { value: "Test Account" },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        vi.mocked(baseDataClient.post).mockResolvedValue({
+            json: () => Promise.resolve({ data: mockData }),
+        });
+        const query = "query { uiapi { query { Account { edges { node { Id Name { value } } } } } } }";
+        const result = await executeGraphQL(query);
+        expect(baseDataClient.post).toHaveBeenCalledWith("/graphql", {
+            query,
+            variables: undefined,
+        });
+        expect(result).toEqual(mockData);
+    });
+    it("should handle GraphQL errors", async () => {
+        const mockErrors = [{ message: "Field not found" }, { message: "Invalid query" }];
+        vi.mocked(baseDataClient.post).mockResolvedValue({
+            json: () => Promise.resolve({ errors: mockErrors }),
+        });
+        const query = "query { invalid }";
+        await expect(executeGraphQL(query)).rejects.toThrow("GraphQL Error: Field not found; Invalid query");
+    });
+    it("should handle network errors", async () => {
+        vi.mocked(baseDataClient.post).mockRejectedValue({
+            status: 500,
+            message: "Network error",
+        });
+        const query = "query { test }";
+        await expect(executeGraphQL(query)).rejects.toThrow("Network error");
+    });
+    it("should pass variables to the GraphQL query", async () => {
+        const mockData = { test: "data" };
+        vi.mocked(baseDataClient.post).mockResolvedValue({
+            json: () => Promise.resolve({ data: mockData }),
+        });
+        const query = "query GetAccount($id: ID!) { account(id: $id) { name } }";
+        const variables = { id: "001" };
+        await executeGraphQL(query, variables);
+        expect(baseDataClient.post).toHaveBeenCalledWith("/graphql", {
+            query,
+            variables,
+        });
+    });
+});

package/dist/api/index.d.ts

@@ -0,0 +1,7 @@
+export { baseClient, baseDataClient, uiApiClient, createClient } from "./clients.js";
+export { executeGraphQL, type GraphQLResponse } from "./graphql.js";
+export { apexClient } from "./apex.js";
+export { getHighRevenueAccounts, type Account } from "./utils/accounts.js";
+export { getRecord, createRecord, updateRecord, deleteRecord } from "./utils/records.js";
+export { getCurrentUser } from "./utils/user.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAGrF,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGvC,OAAO,EAAE,sBAAsB,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE3E,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEzF,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/api/index.js

@@ -0,0 +1,10 @@
+// Core clients
+export { baseClient, baseDataClient, uiApiClient, createClient } from "./clients.js";
+// GraphQL
+export { executeGraphQL } from "./graphql.js";
+// Apex
+export { apexClient } from "./apex.js";
+// Utility functions
+export { getHighRevenueAccounts } from "./utils/accounts.js";
+export { getRecord, createRecord, updateRecord, deleteRecord } from "./utils/records.js";
+export { getCurrentUser } from "./utils/user.js";