Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.
TypeScript accessibilityalternativecloudflarecloudflare-workersdesignfreefrontendopen-sourceradix-uireactremixweb-developmentwebflowwebsite-builderwebsite-developmentwebsiteswebstudio
import { expect, test, vi } from "vitest";
import type { ResourceRequest } from "@webstudio-is/sdk";
import {
loadResource,
resourceLoadConcurrency,
} from "@webstudio-is/sdk/runtime";
import {
loadResourceRequestList,
resourceRequestListSchema,
} from "../services/resource-list-loader.server";
import { getResourceKey } from "./resource-utils";
test("limits each server resource batch to the shared concurrency", () => {
expect(
resourceRequestListSchema.safeParse(
Array.from({ length: resourceLoadConcurrency })
).success
).toBe(true);
expect(
resourceRequestListSchema.safeParse(
Array.from({ length: resourceLoadConcurrency + 1 })
).success
).toBe(false);
});
test("batches Assets while starting and preserving independent remote resources", async () => {
const events: string[] = [];
const assets: ResourceRequest[] = ["Tools", "Updates"].map((category) => ({
name: category,
method: "post",
url: "/$resources/assets",
searchParams: [],
headers: [{ name: "content-type", value: "application/json" }],
body: {
query: {
where: {
field: ["properties", "category"],
operator: "eq",
value: category,
},
},
},
}));
const remotes: ResourceRequest[] = ["First remote", "Second remote"].map(
(name) => ({
name,
method: "get",
url: "https://api.example/posts",
searchParams: [],
headers: [],
})
);
const requests = [assets[0], remotes[0], assets[1], remotes[1]];
const executeAssetQueries = vi.fn(async ({ resourceRequests }) => {
events.push("assets");
return resourceRequests.map((_: Request, index: number) =>
Response.json({
data: {
items: [{ id: `post-${index}`, title: `Post ${index}` }],
totalCount: 1,
hasMore: false,
},
})
);
});
const customFetch = vi.fn<typeof fetch>(async (_input, init) => {
events.push("remote");
expect(init?.signal).toBeInstanceOf(AbortSignal);
return Response.json({ source: "remote" });
});
const request = new Request(
"https://p-090e6e14-ae50-4b2e-bd22-71733cec05bb.localhost/rest/resources-loader",
{ method: "POST" }
);
const output = await loadResourceRequestList(
{
request,
requestList: requests,
sourceOrigin: "https://source.example",
includeDiagnostics: false,
customFetch,
},
{ executeAssetQueries: executeAssetQueries as never, loadResource }
);
expect(events).toEqual(["remote", "remote", "assets"]);
expect(executeAssetQueries).toHaveBeenCalledOnce();
expect(executeAssetQueries.mock.calls[0][0].resourceRequests).toHaveLength(2);
expect(customFetch).toHaveBeenCalledTimes(2);
expect(output.map(([key]) => key)).toEqual(requests.map(getResourceKey));
expect(output[0][1]).toMatchObject({
ok: true,
data: { "post-0": { title: "Post 0" } },
});
expect(output[1][1]).toMatchObject({ ok: true, data: { source: "remote" } });
expect(output[2][1]).toMatchObject({
ok: true,
data: { "post-1": { title: "Post 1" } },
});
expect(output[3][1]).toMatchObject({ ok: true, data: { source: "remote" } });
});
test("records non-bindable server duration and response size", async () => {
const resource: ResourceRequest = {
name: "Remote",
method: "get",
url: "https://api.example/posts",
searchParams: [],
headers: [],
};
const request = new Request(
"https://p-090e6e14-ae50-4b2e-bd22-71733cec05bb.localhost/rest/resources-loader",
{ method: "POST" }
);
const result = {
ok: true,
status: 200,
statusText: "OK",
data: { title: "Post" },
__performance__: {
assetQuery: { resolvedDocumentCount: 2 },
},
};
const now = vi.fn().mockReturnValueOnce(10).mockReturnValueOnce(35.5);
const output = await loadResourceRequestList(
{
request,
requestList: [resource],
sourceOrigin: "https://source.example",
includeDiagnostics: false,
customFetch: vi.fn(),
},
{
executeAssetQueries: vi.fn() as never,
loadResource: vi.fn().mockResolvedValue(result),
now,
}
);
expect(output).toEqual([
[
getResourceKey(resource),
{
...result,
__performance__: {
...result.__performance__,
serverDurationMs: 25.5,
responseBytes: new TextEncoder().encode(
JSON.stringify({
ok: result.ok,
status: result.status,
statusText: result.statusText,
data: result.data,
})
).byteLength,
},
},
],
]);
});
test("captures the actual request and response only for an explicitly inspected resource", async () => {
const resource: ResourceRequest = {
name: "Contact webhook",
method: "post",
url: "https://api.example/contacts?token=query-secret",
searchParams: [],
headers: [
{ name: "content-type", value: "application/json" },
{ name: "authorization", value: "Bearer header-secret" },
],
body: {
email: "[email protected]",
message: "Hello",
password: "body-secret",
},
};
const otherResource: ResourceRequest = {
...resource,
name: "Other webhook",
url: "https://api.example/other",
};
const request = new Request(
"https://p-090e6e14-ae50-4b2e-bd22-71733cec05bb.localhost/rest/resources-loader",
{ method: "POST" }
);
const customFetch = vi.fn<typeof fetch>(async (_input, _init) =>
Response.json(
{ accepted: true },
{ status: 201, headers: { "x-private-result": "response-secret" } }
)
);
const inspectKey = getResourceKey(resource);
const output = await loadResourceRequestList(
{
request,
requestList: [resource, otherResource],
sourceOrigin: "https://source.example",
includeDiagnostics: false,
customFetch,
inspectResourceKey: inspectKey,
},
{ executeAssetQueries: vi.fn() as never, loadResource }
);
expect(output).toMatchObject({
resources: [
[inspectKey, { ok: true, status: 201, data: { accepted: true } }],
[getResourceKey(otherResource), { ok: true, data: { accepted: true } }],
],
inspection: {
resourceId: inspectKey,
resourceName: "Contact webhook",
request: {
method: "POST",
url: "https://api.example/contacts?token=%5Bredacted%5D",
body: {
email: "[email protected]",
message: "Hello",
password: "[redacted]",
},
},
response: {
status: 201,
headers: [
{ name: "content-type", value: "application/json" },
{ name: "x-private-result", value: "response-secret" },
],
body: { accepted: true },
},
},
});
expect(JSON.stringify(output)).not.toContain("query-secret");
expect(JSON.stringify(output)).not.toContain("header-secret");
expect(JSON.stringify(output)).not.toContain("body-secret");
});
test("returns every invalid resource field as structured diagnostics", async () => {
const request = new Request(
"https://p-090e6e14-ae50-4b2e-bd22-71733cec05bb.localhost/rest/resources-loader",
{ method: "POST" }
);
const invalidResource = {
name: 42,
method: "invalid",
searchParams: "invalid",
headers: "invalid",
};
const output = await loadResourceRequestList({
request,
requestList: [invalidResource],
sourceOrigin: "https://source.example",
includeDiagnostics: true,
customFetch: vi.fn(),
});
expect(output[0]?.[1]).toMatchObject({
ok: false,
status: 400,
statusText: "Bad Request",
data: {
error: {
code: "INVALID_REQUEST",
message: "Resource request is invalid",
retryable: false,
details: {
issues: expect.arrayContaining([
expect.objectContaining({ path: ["name"] }),
expect.objectContaining({ path: ["method"] }),
expect.objectContaining({ path: ["url"] }),
expect.objectContaining({ path: ["searchParams"] }),
expect.objectContaining({ path: ["headers"] }),
]),
},
},
},
});
});