Skip to content

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.

fix: Preserve SSG exports with Assets queries (#6102)

Oleg Isonen93fa799cb86b
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 83784fe273..fb6873cae4 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -17,6 +17,32 @@ permissions:
contents: read # to fetch code (actions/checkout)
jobs:
+ ssg-artifact:
+ name: Packaged SSG Assets build
+ if: |
+ github.event_name == 'push' ||
+ github.event_name == 'pull_request' ||
+ (github.event_name == 'pull_request_target' && github.event.label.name == 'safe-to-deploy')
+ timeout-minutes: 20
+ runs-on: ubuntu-24.04-arm
+ environment:
+ name: development
+
+ steps:
+ - uses: actions/checkout@v5
+ with:
+ ref: ${{ github.event.pull_request.head.sha || github.sha }}
+ allow-unsafe-pr-checkout: ${{ github.event_name == 'pull_request_target' && github.event.label.name == 'safe-to-deploy' }}
+
+ - uses: ./.github/actions/submodules-checkout
+ with:
+ submodules-ssh-key: ${{ secrets.PRIVATE_GITHUB_DEPLOY_TOKEN }}
+
+ - uses: ./.github/actions/ci-setup
+
+ - name: Build packaged SSG fixture
+ run: pnpm --filter webstudio test:ssg-package
+
checks:
# Run on push, regular PR (for repo branches), or labeled PR with safe-to-deploy (for forks)
if: |
diff --git a/packages/cli/package.json b/packages/cli/package.json
index d7af69b536..1d5a9faa1b 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -24,6 +24,7 @@
"pretest": "mkdir -p lib && pnpm build:content-runtime",
"evaluations": "tsx --import ../../scripts/register-react-global.ts --conditions=webstudio evaluations/high-impact/run-local-agent.ts",
"test": "vitest run",
+ "test:ssg-package": "tsx --conditions=webstudio scripts/test-ssg-package.ts",
"test:release-smoke": "pnpm build && tsx --conditions=webstudio scripts/release-smoke.ts",
"test:release-smoke:model": "WEBSTUDIO_RELEASE_SMOKE_MODEL_EVAL_REQUIRED=1 pnpm test:release-smoke",
"test:release-smoke:registry": "tsx --conditions=webstudio scripts/release-smoke.ts"
diff --git a/packages/cli/scripts/test-ssg-package.ts b/packages/cli/scripts/test-ssg-package.ts
new file mode 100644
index 0000000000..09168da4ed
--- /dev/null
+++ b/packages/cli/scripts/test-ssg-package.ts
@@ -0,0 +1,256 @@
+import { execFile } from "node:child_process";
+import assert from "node:assert/strict";
+import {
+ mkdtemp,
+ mkdir,
+ readFile,
+ rm,
+ stat,
+ writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import type {
+ Instance,
+ Page,
+ Resource,
+ StructuredAssetQueryFilterBinding,
+} from "@webstudio-is/sdk";
+import {
+ createStructuredAssetQueryResourceBody,
+ encodeDataSourceVariable,
+ SYSTEM_VARIABLE_ID,
+} from "@webstudio-is/sdk";
+import type { AssetFileDocument } from "@webstudio-is/content-engine";
+import {
+ createAssetIndex,
+ createCanonicalAssetFileEntry,
+} from "@webstudio-is/content-engine/compiler";
+import {
+ createPageFixture,
+ createPublishedProjectBundleFixture,
+} from "@webstudio-is/protocol/fixtures";
+import type { PublishedProjectBundle } from "@webstudio-is/protocol";
+
+const execFileAsync = promisify(execFile);
+const repositoryRoot = join(import.meta.dirname, "../../..");
+const projectId = "ssg-assets-smoke";
+const postDataSourceId = "post-data";
+const systemExpression = encodeDataSourceVariable(SYSTEM_VARIABLE_ID);
+const renderedTitle = "Hello from packaged Assets";
+
+const run = async (args: string[], cwd = repositoryRoot) => {
+ try {
+ return await execFileAsync("pnpm", args, {
+ cwd,
+ maxBuffer: 50 * 1024 * 1024,
+ });
+ } catch (error) {
+ if (error instanceof Error && "stdout" in error && "stderr" in error) {
+ error.message += `\n${String(error.stdout)}\n${String(error.stderr)}`;
+ }
+ throw error;
+ }
+};
+
+const createAssetsResource = ({
+ id,
+ filter,
+ result = "many",
+}: {
+ id: string;
+ filter: StructuredAssetQueryFilterBinding;
+ result?: "many" | "one";
+}): Resource => ({
+ id,
+ name: id,
+ control: "system",
+ method: "post",
+ url: '"/$resources/assets"',
+ headers: [],
+ body: createStructuredAssetQueryResourceBody({
+ result,
+ where: { all: [filter] },
+ sort: [],
+ limit: result === "one" ? "1" : "20",
+ offset: "0",
+ output: { mode: "all", includeMetadata: false },
+ content: { mode: "none" },
+ }),
+});
+
+const createFixture = async (): Promise<PublishedProjectBundle> => {
+ const document: AssetFileDocument = {
+ _id: "post-1",
+ _type: "asset.file",
+ name: "hello-world.md",
+ path: "blog/hello-world.md",
+ key: "hello-world",
+ extension: "md",
+ mimeType: "text/markdown",
+ size: 13,
+ revision: "post-1-revision",
+ contentRef: "hello-world.md",
+ properties: {
+ slug: "hello-world",
+ title: renderedTitle,
+ draft: false,
+ },
+ };
+ const assetIndex = await createAssetIndex({
+ projectId,
+ entries: [createCanonicalAssetFileEntry({ projectId, document })],
+ });
+ const pages: Page[] = [
+ createPageFixture({ rootInstanceId: "home-root" }),
+ createPageFixture({
+ id: "unrelated-query",
+ name: "Unrelated query",
+ title: "Unrelated query",
+ path: "/unrelated/:slug",
+ rootInstanceId: "unrelated-root",
+ }),
+ createPageFixture({
+ id: "post",
+ name: "Post",
+ title: `${encodeDataSourceVariable(postDataSourceId)}.data?.properties?.title ?? "Missing post"`,
+ path: "/posts/:slug",
+ rootInstanceId: "post-root",
+ }),
+ ];
+ const instances: PublishedProjectBundle["build"]["instances"] = pages.map(
+ ({ rootInstanceId }) => [
+ rootInstanceId,
+ {
+ type: "instance",
+ id: rootInstanceId,
+ component: "Box",
+ children: [],
+ } satisfies Instance,
+ ]
+ );
+ const unrelatedResource = createAssetsResource({
+ id: "unrelated-posts",
+ filter: {
+ field: ["properties", "draft"],
+ operator: "eq",
+ value: "false",
+ },
+ });
+ const postResource = createAssetsResource({
+ id: "post",
+ result: "one",
+ filter: {
+ field: ["properties", "slug"],
+ operator: "eq",
+ value: `${systemExpression}.params.slug`,
+ },
+ });
+
+ return createPublishedProjectBundleFixture({
+ projectDomain: "example.com",
+ projectTitle: "SSG Assets package smoke",
+ page: pages[0],
+ pages,
+ assetIndex,
+ buildPages: {
+ homePageId: pages[0].id,
+ rootFolderId: "root",
+ pages,
+ folders: [
+ {
+ id: "root",
+ name: "Root",
+ slug: "",
+ children: pages.map(({ id }) => id),
+ },
+ ],
+ },
+ build: {
+ projectId,
+ instances,
+ dataSources: [
+ [
+ "unrelated-posts-data",
+ {
+ id: "unrelated-posts-data",
+ type: "resource",
+ name: "unrelatedPosts",
+ resourceId: unrelatedResource.id,
+ scopeInstanceId: "unrelated-root",
+ },
+ ],
+ [
+ postDataSourceId,
+ {
+ id: postDataSourceId,
+ type: "resource",
+ name: "post",
+ resourceId: postResource.id,
+ scopeInstanceId: "post-root",
+ },
+ ],
+ ],
+ resources: [
+ [unrelatedResource.id, unrelatedResource],
+ [postResource.id, postResource],
+ ],
+ },
+ });
+};
+
+const fixtureDirectory = await mkdtemp(
+ join(tmpdir(), "webstudio-ssg-package-")
+);
+
+try {
+ await run(["--filter", "ssg-cloudflare-pages^...", "run", "build"]);
+ await run(["--filter", "ssg-cloudflare-pages", "deploy", fixtureDirectory]);
+ await rm(join(fixtureDirectory, "pages"), { recursive: true, force: true });
+ await mkdir(join(fixtureDirectory, ".webstudio"), { recursive: true });
+ await writeFile(
+ join(fixtureDirectory, ".webstudio", "data.json"),
+ JSON.stringify(await createFixture()),
+ "utf8"
+ );
+
+ const cliBuild = await run(
+ [
+ "-C",
+ fixtureDirectory,
+ "exec",
+ "webstudio",
+ "build",
+ "--no-assets",
+ "--template",
+ "ssg",
+ "--template",
+ "internal",
+ ],
+ fixtureDirectory
+ );
+ const siteBuild = await run(["-C", fixtureDirectory, "build"]);
+ const output = `${cliBuild.stdout}\n${cliBuild.stderr}\n${siteBuild.stdout}\n${siteBuild.stderr}`;
+ assert.doesNotMatch(output, /Failed to load resource request/);
+
+ const html = await readFile(
+ join(
+ fixtureDirectory,
+ "dist",
+ "client",
+ "posts",
+ "hello-world",
+ "index.html"
+ ),
+ "utf8"
+ );
+ assert.match(html, new RegExp(`<title>${renderedTitle}</title>`));
+ await assert.rejects(
+ stat(join(fixtureDirectory, "dist", "client", "unrelated")),
+ { code: "ENOENT" },
+ "An unrelated Assets query produced a dynamic SSG path."
+ );
+} finally {
+ await rm(fixtureDirectory, { recursive: true, force: true });
+}
diff --git a/packages/cli/src/prebuild.test.ts b/packages/cli/src/prebuild.test.ts
index dbf4648ab3..e1096192e5 100644
--- a/packages/cli/src/prebuild.test.ts
+++ b/packages/cli/src/prebuild.test.ts
@@ -35,6 +35,8 @@ import {
import { createPublishedAssetResourceFetch } from "@webstudio-is/content-engine/runtime";
import {
createStructuredAssetQueryResourceBody,
+ encodeDataSourceVariable,
+ SYSTEM_VARIABLE_ID,
type Resource,
} from "@webstudio-is/sdk";
import {
@@ -2238,6 +2240,39 @@ describe("prebuild", () => {
);
});
+ test("ignores Assets queries unrelated to dynamic SSG route parameters", async () => {
+ const index = await createTestAssetIndex({
+ ...indexedDocument,
+ properties: { slug: "hello-world", draft: false },
+ });
+ const resource = createQueryResource();
+ resource.body = createStructuredAssetQueryResourceBody({
+ where: {
+ all: [
+ {
+ field: ["properties", "draft"],
+ operator: "eq",
+ value: "false",
+ },
+ ],
+ },
+ sort: [],
+ limit: "20",
+ offset: "0",
+ output: { mode: "all", includeMetadata: true },
+ content: { mode: "none" },
+ });
+
+ expect(
+ getAssetResourcePrerenderPaths({
+ pagePath: "/blog/:slug",
+ resources: [["posts", resource]],
+ index,
+ requireCompleteEnumeration: true,
+ })
+ ).toEqual([]);
+ });
+
test("prerenders asset routes bound with optional member expressions", async () => {
const index = await createTestAssetIndex({
...indexedDocument,
@@ -2270,6 +2305,38 @@ describe("prebuild", () => {
).toEqual(["/blog/hello-world"]);
});
+ test("prerenders asset routes bound with the persisted system variable", async () => {
+ const index = await createTestAssetIndex({
+ ...indexedDocument,
+ properties: { slug: "hello-world" },
+ });
+ const resource = createQueryResource();
+ resource.body = createStructuredAssetQueryResourceBody({
+ where: {
+ all: [
+ {
+ field: ["properties", "slug"],
+ operator: "eq",
+ value: `${encodeDataSourceVariable(SYSTEM_VARIABLE_ID)}.params.slug`,
+ },
+ ],
+ },
+ sort: [],
+ limit: "1",
+ offset: "0",
+ output: { mode: "all", includeMetadata: true },
+ content: { mode: "none" },
+ });
+
+ expect(
+ getAssetResourcePrerenderPaths({
+ pagePath: "/blog/:slug",
+ resources: [["post", resource]],
+ index,
+ })
+ ).toEqual(["/blog/hello-world"]);
+ });
+
test("deduplicates collection routes matched by multiple assets", async () => {
const index = await createTestAssetIndex([
{ ...indexedDocument, properties: { slug: "shared" } },
diff --git a/packages/cli/src/prebuild.ts b/packages/cli/src/prebuild.ts
index 2754c25ab7..345922de79 100644
--- a/packages/cli/src/prebuild.ts
+++ b/packages/cli/src/prebuild.ts
@@ -35,6 +35,7 @@ import {
replaceFormActionsWithResources,
isCoreComponent,
coreMetas,
+ decodeDataSourceVariable,
SYSTEM_VARIABLE_ID,
generateCss,
ROOT_INSTANCE_ID,
@@ -101,6 +102,7 @@ import { createFramework as createRemixFramework } from "./framework-remix";
import { createFramework as createReactRouterFramework } from "./framework-react-router";
import { createFramework as createVikeSsgFramework } from "./framework-vike-ssg";
import { routeTemplatesDirectory } from "./framework";
+import { readSsgAssetResourceFetchTemplate } from "./ssg-asset-resource-fetch-template";
export const generatedFilesManifest = join(
".webstudio",
@@ -111,10 +113,6 @@ const contentRuntimeBundleUrl = new URL(
import.meta.url
);
const contentRuntimeFile = "$resources.asset-query-vendor.js";
-const ssgAssetResourceFetchTemplateUrl = new URL(
- "../templates/ssg/app/asset-resource-fetch.ts",
- import.meta.url
-);
const appRoot = "app";
const generatedDir = join(appRoot, "__generated__");
const routesDir = join(appRoot, "routes");
@@ -138,7 +136,12 @@ type SiteDataByPage = {
const getBoundSystemRouteParameter = (expression: string) => {
const path = parseStaticMemberPath(expression);
- return path?.length === 3 && path[0] === "system" && path[1] === "params"
+ const variable = path?.[0];
+ const isSystem =
+ variable === "system" ||
+ (variable !== undefined &&
+ decodeDataSourceVariable(variable) === SYSTEM_VARIABLE_ID);
+ return path?.length === 3 && isSystem && path[1] === "params"
? path[2]
: undefined;
};
@@ -320,33 +323,37 @@ export const getAssetResourcePrerenderPaths = ({
});
let enumerableConfigurations = configurations;
if (requireCompleteEnumeration && configurations.length > 0) {
- const configurationsByParameters = configurations.flatMap(
- (configuration) => {
- const boundRouteParameters = new Set(
- getQueryConditions(configuration.where).flatMap((condition) => {
- const routeParameter = getBoundSystemRouteParameter(
- condition.value
- );
- return routeParameter !== undefined &&
- routeParameterNames.has(routeParameter)
- ? [routeParameter]
- : [];
- })
- );
- return [...routeParameterNames].every((routeParameter) =>
+ const configurationsByParameters = configurations.map((configuration) => {
+ const boundRouteParameters = new Set(
+ getQueryConditions(configuration.where).flatMap((condition) => {
+ const routeParameter = getBoundSystemRouteParameter(condition.value);
+ return routeParameter !== undefined &&
+ routeParameterNames.has(routeParameter)
+ ? [routeParameter]
+ : [];
+ })
+ );
+ return { configuration, boundRouteParameters };
+ });
+ const routeConfigurations = configurationsByParameters.filter(
+ ({ boundRouteParameters }) => boundRouteParameters.size > 0
+ );
+ const completeRouteConfigurations = routeConfigurations.filter(
+ ({ boundRouteParameters }) =>
+ [...routeParameterNames].every((routeParameter) =>
boundRouteParameters.has(routeParameter)
)
- ? [{ configuration, boundRouteParameters }]
- : [];
- }
);
- if (configurationsByParameters.length === 0) {
+ if (
+ routeConfigurations.length > 0 &&
+ completeRouteConfigurations.length === 0
+ ) {
throw new Error(
"Dynamic SSG route parameters must be completely enumerated by one Assets query"
);
}
let firstUnenumerableParameter: string | undefined;
- enumerableConfigurations = configurationsByParameters.flatMap(
+ enumerableConfigurations = completeRouteConfigurations.flatMap(
({ configuration, boundRouteParameters }) => {
for (const routeParameter of boundRouteParameters) {
if (
@@ -363,7 +370,10 @@ export const getAssetResourcePrerenderPaths = ({
return [configuration];
}
);
- if (enumerableConfigurations.length === 0) {
+ if (
+ completeRouteConfigurations.length > 0 &&
+ enumerableConfigurations.length === 0
+ ) {
throw new Error(
`Dynamic SSG route parameter ${JSON.stringify(firstUnenumerableParameter)} cannot be completely enumerated from every Assets query branch`
);
@@ -496,7 +506,7 @@ const configureSsgAssetResourceFetch = async ({
const ssgFetchPath = join(cwd(), "app", "asset-resource-fetch.ts");
if (existsSync(ssgFetchPath)) {
const content = enabled
- ? await readFile(ssgAssetResourceFetchTemplateUrl, "utf8")
+ ? await readSsgAssetResourceFetchTemplate()
: `export const createSsgAssetResourceFetch = (_options: unknown) =>
async (_input: RequestInfo | URL, _init?: RequestInit) => undefined;\n`;
await writeFileIfChanged(ssgFetchPath, content);
diff --git a/packages/cli/src/ssg-asset-resource-fetch-template.test.ts b/packages/cli/src/ssg-asset-resource-fetch-template.test.ts
new file mode 100644
index 0000000000..89748a4d2f
--- /dev/null
+++ b/packages/cli/src/ssg-asset-resource-fetch-template.test.ts
@@ -0,0 +1,70 @@
+import { cp, mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { afterEach, expect, test } from "vitest";
+import { build } from "vite";
+
+const packageRoot = join(import.meta.dirname, "..");
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+ await Promise.all(
+ temporaryDirectories
+ .splice(0)
+ .map((directory) => rm(directory, { recursive: true, force: true }))
+ );
+});
+
+test("reads the SSG asset resource fetch template from the bundled CLI package", async () => {
+ const temporaryDirectory = await mkdtemp(
+ join(tmpdir(), "webstudio-ssg-template-")
+ );
+ temporaryDirectories.push(temporaryDirectory);
+ const outputDirectory = join(temporaryDirectory, "package", "lib");
+ const templatePath = join(
+ "templates",
+ "ssg",
+ "app",
+ "asset-resource-fetch.ts"
+ );
+ await mkdir(dirname(join(temporaryDirectory, "package", templatePath)), {
+ recursive: true,
+ });
+ await cp(
+ join(packageRoot, templatePath),
+ join(temporaryDirectory, "package", templatePath)
+ );
+
+ await build({
+ configFile: false,
+ logLevel: "silent",
+ build: {
+ target: "node22",
+ outDir: outputDirectory,
+ emptyOutDir: false,
+ lib: {
+ entry: join(packageRoot, "src", "ssg-asset-resource-fetch-template.ts"),
+ formats: ["es"],
+ fileName: "template-reader",
+ },
+ rollupOptions: {
+ external: ["node:fs/promises"],
+ },
+ },
+ });
+
+ const bundledModule = (await import(
+ `${pathToFileURL(join(outputDirectory, "template-reader.js"))}?test=${crypto.randomUUID()}`
+ )) as {
+ readSsgAssetResourceFetchTemplate: () => Promise<string>;
+ };
+ const expectedTemplate = await readFile(
+ join(packageRoot, templatePath),
+ "utf8"
+ );
+
+ await expect(bundledModule.readSsgAssetResourceFetchTemplate()).resolves.toBe(
+ expectedTemplate
+ );
+});
diff --git a/packages/cli/src/ssg-asset-resource-fetch-template.ts b/packages/cli/src/ssg-asset-resource-fetch-template.ts
new file mode 100644
index 0000000000..2a28ee1b3b
--- /dev/null
+++ b/packages/cli/src/ssg-asset-resource-fetch-template.ts
@@ -0,0 +1,9 @@
+import { readFile } from "node:fs/promises";
+
+const templateUrl = new URL(
+ /* @vite-ignore */ "../templates/ssg/app/asset-resource-fetch.ts",
+ import.meta.url
+);
+
+export const readSsgAssetResourceFetchTemplate = () =>
+ readFile(templateUrl, "utf8");