@wasp.sh/wasp-cli-darwin-arm64-unknown 0.24.0 → 0.25.0

package/data/packages/prisma/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasp-prisma",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "type": "module",
   "author": "Wasp Team",
   "license": "MIT",
@@ -20,10 +20,10 @@
   "devDependencies": {
     "@types/node": "^22.17.0",
     "@types/tmp": "^0.2.3",
-    "@typescript-eslint/eslint-plugin": "^5.48.0",
-    "@typescript-eslint/parser": "^5.48.0",
-    "eslint": "^8.31.0",
-    "typescript": "^5.1.3",
-    "vitest": "^4.0.8"
+    "@typescript-eslint/eslint-plugin": "^8.32.1",
+    "@typescript-eslint/parser": "^8.32.1",
+    "eslint": "^8.57.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
   }
 }

package/data/packages/spec/dist/__tests__/spec/appAnalyzer.unit.test.js

@@ -1,8 +1,8 @@
 import { afterEach, describe, expect, test, vi } from "vitest";
 import { loadWaspTsSpecDefaultExport } from "../../src/spec-pipeline/loadWaspTsSpec.js";
 import { analyzeApp } from "../../src/spec/appAnalyzer.js";
-import { mapApp } from "../../src/spec/mapApp.js";
-import { SpecUserError } from "../../src/spec/specUserError.js";
+import { convertWaspSpecToAppSpec } from "../../src/spec/mapper/index.js";
+import { WaspSpecUserError } from "../../src/spec/waspSpecUserError.js";
 import * as Fixtures from "./testFixtures.js";
 vi.mock("../../src/spec-pipeline/loadWaspTsSpec.js", () => ({
     loadWaspTsSpecDefaultExport: vi.fn(),
@@ -50,11 +50,11 @@ describe("analyzeApp", () => {
             entityNames: entities,
         });
         if (shouldReturnError) {
-            await expect(analyze()).rejects.toThrowError(SpecUserError);
+            await expect(analyze()).rejects.toThrowError(WaspSpecUserError);
         }
         else {
             const result = await analyze();
-            const expected = mapApp(app, {
+            const expected = convertWaspSpecToAppSpec(app, {
                 entityNames: entities,
                 projectRootDir: "/project",
             });

package/data/packages/spec/dist/__tests__/spec/mapApp.unit.test.js

@@ -1,25 +1,39 @@
 import { describe, expect, test } from "vitest";
-import * as AppSpecMapper from "../../src/spec/mapApp.js";
-import { app, page, route } from "../../src/spec/publicApi/index.js";
+import { normalizePrerender } from "../../src/normalizePrerender.js";
+import * as AppSpecMapper from "../../src/spec/mapper/app.js";
+import { makeRefParser, } from "../../src/spec/mapper/context.js";
+import { convertWaspSpecToAppSpec } from "../../src/spec/mapper/index.js";
+import * as SpecElementMapper from "../../src/spec/mapper/specElements.js";
+import { api, app, page, query, route, } from "../../src/spec/publicApi/index.js";
 import { getRefObjectDeclarationName, mapRefObject, } from "../../src/spec/refObject.js";
 import * as Fixtures from "./testFixtures.js";
 function mapRefObjectForMockProjectDir(refObject) {
     return mapRefObject(refObject, { projectRootDir: Fixtures.MOCK_PROJECT_DIR });
 }
 function makeMapperContext({ entityNames = [], routeNames = [], } = {}) {
-    return {
-        entityRefParser: AppSpecMapper.makeRefParser("Entity", entityNames),
-        routeRefParser: AppSpecMapper.makeRefParser("Route", routeNames),
-        mapRefObject: mapRefObjectForMockProjectDir,
+    const ctx = {
+        resolveEntityRef: makeRefParser("Entity", entityNames),
+        resolveRouteRef: makeRefParser("Route", routeNames),
+        parseRefObject: mapRefObjectForMockProjectDir,
+        // For testing, the individual mapper functions only need the `AppSpec.Ref`.
+        collectSpecElement(specElement) {
+            const decl = SpecElementMapper.mapSpecElement(specElement, ctx);
+            return SpecElementMapper.declToRef(decl);
+        },
     };
+    return ctx;
+}
+function getSpecElementDeclName(specElement) {
+    return SpecElementMapper.mapSpecElement(specElement, makeMapperContext())
+        .declName;
 }
 function mapMockApp(app, entityNames) {
-    return AppSpecMapper.mapApp(app, {
+    return convertWaspSpecToAppSpec(app, {
         entityNames,
         projectRootDir: Fixtures.MOCK_PROJECT_DIR,
     });
 }
-describe("mapApp", () => {
+describe("convertWaspSpecToAppSpec", () => {
     test("should map minimal app correctly", () => {
         const entityNames = Fixtures.getEntities("minimal");
         const app = Fixtures.getApp("minimal");
@@ -89,12 +103,8 @@ describe("mapApp", () => {
             entityNames,
             routeNames: [emailVerifyRoute.name, passwordResetRoute.name],
         });
-        // TODO: Reaching into `getRefObjectDeclarationName` here is not ideal — it leaks
-        // an orchestrator-internal helper into the test. Revisit once we have a
-        // higher-level name-derivation system: either a part-agnostic
-        // `deriveDeclName(part)`, or a part-specific dispatch (mirroring how we
-        // have one mapper per kind). The test should delegate to whatever
-        // surfaces.
+        // Decls come out in registration order: each `spec` element in listing
+        // order, with a route's page registered right before the route itself.
         expect(result).toStrictEqual([
             {
                 declType: "App",
@@ -111,67 +121,23 @@ describe("mapApp", () => {
                     webSocket: AppSpecMapper.mapWebSocket(webSocket, ctx),
                 },
             },
-            {
-                declType: "Page",
-                declName: getRefObjectDeclarationName(page.component),
-                declValue: AppSpecMapper.mapPage(page, ctx),
-            },
-            {
-                declType: "Page",
-                declName: getRefObjectDeclarationName(emailVerifyRoute.page.component),
-                declValue: AppSpecMapper.mapPage(emailVerifyRoute.page, ctx),
-            },
-            {
-                declType: "Page",
-                declName: getRefObjectDeclarationName(passwordResetRoute.page.component),
-                declValue: AppSpecMapper.mapPage(passwordResetRoute.page, ctx),
-            },
-            {
-                declType: "Route",
-                declName: route.name,
-                declValue: AppSpecMapper.mapRoute(route),
-            },
-            {
-                declType: "Route",
-                declName: emailVerifyRoute.name,
-                declValue: AppSpecMapper.mapRoute(emailVerifyRoute),
-            },
-            {
-                declType: "Route",
-                declName: passwordResetRoute.name,
-                declValue: AppSpecMapper.mapRoute(passwordResetRoute),
-            },
-            {
-                declType: "Query",
-                declName: getRefObjectDeclarationName(query.fn),
-                declValue: AppSpecMapper.mapQuery(query, ctx),
-            },
-            {
-                declType: "Api",
-                declName: getRefObjectDeclarationName(api.fn),
-                declValue: AppSpecMapper.mapApi(api, ctx),
-            },
-            {
-                declType: "ApiNamespace",
-                declName: getRefObjectDeclarationName(apiNamespace.middlewareConfigFn),
-                declValue: AppSpecMapper.mapApiNamespace(apiNamespace, ctx),
-            },
-            {
-                declType: "Job",
-                declName: getRefObjectDeclarationName(job.fn),
-                declValue: AppSpecMapper.mapJob(job, ctx),
-            },
-            {
-                declType: "Crud",
-                declName: crud.name,
-                declValue: AppSpecMapper.mapCrud(crud, ctx),
-            },
+            SpecElementMapper.mapPageSpec(page, ctx),
+            SpecElementMapper.mapRouteSpec(route, ctx),
+            SpecElementMapper.mapQuerySpec(query, ctx),
+            SpecElementMapper.mapApiSpec(api, ctx),
+            SpecElementMapper.mapApiNamespaceSpec(apiNamespace, ctx),
+            SpecElementMapper.mapJobSpec(job, ctx),
+            SpecElementMapper.mapCrudSpec(crud, ctx),
+            SpecElementMapper.mapPageSpec(emailVerifyRoute.page, ctx),
+            SpecElementMapper.mapRouteSpec(emailVerifyRoute, ctx),
+            SpecElementMapper.mapPageSpec(passwordResetRoute.page, ctx),
+            SpecElementMapper.mapRouteSpec(passwordResetRoute, ctx),
         ]);
     });
     test("dedups a page referenced explicitly twice", () => {
         const refObject = Fixtures.getRefObject("minimal", "default");
-        const pageName = getRefObjectDeclarationName(refObject);
         const page1 = page(refObject);
+        const pageName = getSpecElementDeclName(page1);
         const page2 = page(refObject);
         const app = Fixtures.getMinimalAppWithSpec([page1, page2]);
         const decls = mapMockApp(app, []);
@@ -182,8 +148,8 @@ describe("mapApp", () => {
     });
     test("dedups a page referenced via a route shorthand twice", () => {
         const refObject = Fixtures.getRefObject("minimal", "default");
-        const pageName = getRefObjectDeclarationName(refObject);
         const page1 = page(refObject);
+        const pageName = getSpecElementDeclName(page1);
         const page2 = page(refObject);
         const route1 = route("Route1", "/", page1);
         const route2 = route("Route2", "/", page2);
@@ -196,8 +162,8 @@ describe("mapApp", () => {
     });
     test("dedups a page referenced explicitly and via a route shorthand", () => {
         const refObject = Fixtures.getRefObject("minimal", "default");
-        const pageName = getRefObjectDeclarationName(refObject);
         const page1 = page(refObject);
+        const pageName = getSpecElementDeclName(page1);
         const page2 = page(refObject);
         const route1 = route("Route1", "/", page2);
         const app = Fixtures.getMinimalAppWithSpec([page1, route1]);
@@ -209,16 +175,16 @@ describe("mapApp", () => {
     });
     test("throws when the same page name is produced with differing configs explicitly", () => {
         const refObject = Fixtures.getRefObject("minimal", "default");
-        const pageName = getRefObjectDeclarationName(refObject);
         const page1 = page(refObject);
+        const pageName = getSpecElementDeclName(page1);
         const page2 = page(refObject, { authRequired: true });
         const app = Fixtures.getMinimalAppWithSpec([page1, page2]);
         expect(() => mapMockApp(app, [])).toThrow(`Conflicting configurations for the page \`${pageName}\``);
     });
     test("throws when the same page name is produced with differing configs via a route shorthand twice", () => {
         const refObject = Fixtures.getRefObject("minimal", "default");
-        const pageName = getRefObjectDeclarationName(refObject);
         const page1 = page(refObject);
+        const pageName = getSpecElementDeclName(page1);
         const page2 = page(refObject, { authRequired: true });
         const route1 = route("Route1", "/", page1);
         const route2 = route("Route2", "/", page2);
@@ -227,14 +193,41 @@ describe("mapApp", () => {
     });
     test("throws when the same page name is produced with differing configs explicitly and via a route shorthand", () => {
         const refObject = Fixtures.getRefObject("minimal", "default");
-        const pageName = getRefObjectDeclarationName(refObject);
         const page1 = page(refObject);
+        const pageName = getSpecElementDeclName(page1);
         const page2 = page(refObject, { authRequired: true });
         const route1 = route("Route2", "/", page2);
         const app = Fixtures.getMinimalAppWithSpec([page1, route1]);
         expect(() => mapMockApp(app, [])).toThrow(`Conflicting configurations for the page \`${pageName}\``);
     });
-    // TODO: duplicate query name → throw.
+    test("allows decls of different types to share a name", () => {
+        const refObject = Fixtures.getRefObject("minimal", "named");
+        const query1 = query(refObject);
+        const api1 = api("GET", "/foo/bar", refObject);
+        const app = Fixtures.getMinimalAppWithSpec([query1, api1]);
+        const decls = mapMockApp(app, []);
+        const declTypes = decls.map((d) => d.declType);
+        expect(declTypes).toEqual(["App", "Query", "Api"]);
+        expect(getSpecElementDeclName(query1)).toBe(getSpecElementDeclName(api1));
+    });
+    test("dedups a query listed twice with identical configs", () => {
+        const refObject = Fixtures.getRefObject("minimal", "named");
+        const query1 = query(refObject);
+        const query2 = query(refObject);
+        const app = Fixtures.getMinimalAppWithSpec([query1, query2]);
+        const decls = mapMockApp(app, []);
+        const queryNames = decls
+            .filter((d) => d.declType === "Query")
+            .map((d) => d.declName);
+        expect(queryNames).toEqual([getSpecElementDeclName(query1)]);
+    });
+    test("throws when two queries share a name with differing configs", () => {
+        const refObject = Fixtures.getRefObject("minimal", "named");
+        const query1 = query(refObject);
+        const query2 = query(refObject, { auth: true });
+        const app = Fixtures.getMinimalAppWithSpec([query1, query2]);
+        expect(() => mapMockApp(app, [])).toThrow(`Conflicting configurations for the query \`${getSpecElementDeclName(query1)}\``);
+    });
 });
 describe("mapPage", () => {
     test("should map minimal config correctly", () => {
@@ -245,10 +238,14 @@ describe("mapPage", () => {
     });
     function testMapPage(page) {
         const ctx = makeMapperContext();
-        const result = AppSpecMapper.mapPage(page, ctx);
+        const result = SpecElementMapper.mapPageSpec(page, ctx);
         expect(result).toStrictEqual({
-            component: mapRefObjectForMockProjectDir(page.component),
-            authRequired: page.authRequired,
+            declType: "Page",
+            declName: getRefObjectDeclarationName(page.component),
+            declValue: {
+                component: mapRefObjectForMockProjectDir(page.component),
+                authRequired: page.authRequired,
+            },
         });
     }
 });
@@ -259,16 +256,27 @@ describe("mapRoute", () => {
     test("should map full config correctly", () => {
         testMapRoute(Fixtures.getRoute("full"));
     });
+    test("should expand prerender: true to the route's own path", () => {
+        const result = SpecElementMapper.mapRouteSpec(route("LandingRoute", "/landing", Fixtures.getPage("minimal"), {
+            prerender: true,
+        }), makeMapperContext());
+        expect(result.declValue.prerender).toEqual(["/landing"]);
+    });
     function testMapRoute(route) {
-        const result = AppSpecMapper.mapRoute(route);
+        const ctx = makeMapperContext();
+        const result = SpecElementMapper.mapRouteSpec(route, ctx);
         expect(result).toStrictEqual({
-            path: route.path,
-            to: {
-                name: getRefObjectDeclarationName(route.page.component),
-                declType: "Page",
+            declType: "Route",
+            declName: route.name,
+            declValue: {
+                path: route.path,
+                to: {
+                    name: getRefObjectDeclarationName(route.page.component),
+                    declType: "Page",
+                },
+                prerender: normalizePrerender(route.prerender, route.path),
+                lazy: route.lazy,
             },
-            prerender: route.prerender,
-            lazy: route.lazy,
         });
     }
 });
@@ -282,15 +290,19 @@ describe("mapQuery", () => {
     test("should throw if entity ref is not provided", () => {
         const query = Fixtures.getQuery("full");
         const ctx = makeMapperContext({ entityNames: [] });
-        expect(() => AppSpecMapper.mapQuery(query, ctx)).toThrow();
+        expect(() => SpecElementMapper.mapQuerySpec(query, ctx)).toThrow();
     });
     function testMapQuery(query) {
         const ctx = makeMapperContext({ entityNames: query.entities ?? [] });
-        const result = AppSpecMapper.mapQuery(query, ctx);
+        const result = SpecElementMapper.mapQuerySpec(query, ctx);
         expect(result).toStrictEqual({
-            fn: mapRefObjectForMockProjectDir(query.fn),
-            entities: query.entities?.map(ctx.entityRefParser),
-            auth: query.auth,
+            declType: "Query",
+            declName: getRefObjectDeclarationName(query.fn),
+            declValue: {
+                fn: mapRefObjectForMockProjectDir(query.fn),
+                entities: query.entities?.map(ctx.resolveEntityRef),
+                auth: query.auth,
+            },
         });
     }
 });
@@ -304,15 +316,19 @@ describe("mapAction", () => {
     test("should throw if entity ref is not provided", () => {
         const action = Fixtures.getAction("full");
         const ctx = makeMapperContext({ entityNames: [] });
-        expect(() => AppSpecMapper.mapAction(action, ctx)).toThrow();
+        expect(() => SpecElementMapper.mapActionSpec(action, ctx)).toThrow();
     });
     function testMapAction(action) {
         const ctx = makeMapperContext({ entityNames: action.entities ?? [] });
-        const result = AppSpecMapper.mapAction(action, ctx);
+        const result = SpecElementMapper.mapActionSpec(action, ctx);
         expect(result).toStrictEqual({
-            fn: mapRefObjectForMockProjectDir(action.fn),
-            entities: action.entities?.map(ctx.entityRefParser),
-            auth: action.auth,
+            declType: "Action",
+            declName: getRefObjectDeclarationName(action.fn),
+            declValue: {
+                fn: mapRefObjectForMockProjectDir(action.fn),
+                entities: action.entities?.map(ctx.resolveEntityRef),
+                auth: action.auth,
+            },
         });
     }
 });
@@ -365,7 +381,7 @@ describe("mapAuth", () => {
         }
         const result = AppSpecMapper.mapAuth(auth, ctx);
         expect(result).toStrictEqual({
-            userEntity: ctx.entityRefParser(auth.userEntity),
+            userEntity: ctx.resolveEntityRef(auth.userEntity),
             methods: AppSpecMapper.mapAuthMethods(auth.methods, ctx),
             onAuthFailedRedirectTo: auth.onAuthFailedRedirectTo,
             onAuthSucceededRedirectTo: auth.onAuthSucceededRedirectTo,
@@ -518,7 +534,7 @@ describe("mapEmailFlow", () => {
         }
         const result = AppSpecMapper.mapEmailFlow(emailFlow, ctx);
         expect(result).toStrictEqual({
-            clientRoute: ctx.routeRefParser(emailFlow.clientRoute),
+            clientRoute: ctx.resolveRouteRef(emailFlow.clientRoute),
             getEmailContentFn: emailFlow.getEmailContentFn &&
                 mapRefObjectForMockProjectDir(emailFlow.getEmailContentFn),
         });
@@ -568,18 +584,22 @@ describe("mapApi", () => {
     test("should throw if entity refs are not provided", () => {
         const api = Fixtures.getApi("full");
         const ctx = makeMapperContext({ entityNames: [] });
-        expect(() => AppSpecMapper.mapApi(api, ctx)).toThrow();
+        expect(() => SpecElementMapper.mapApiSpec(api, ctx)).toThrow();
     });
     function testMapApi(api) {
         const ctx = makeMapperContext({ entityNames: api.entities ?? [] });
-        const result = AppSpecMapper.mapApi(api, ctx);
+        const result = SpecElementMapper.mapApiSpec(api, ctx);
         expect(result).toStrictEqual({
-            fn: mapRefObjectForMockProjectDir(api.fn),
-            middlewareConfigFn: api.middlewareConfigFn &&
-                mapRefObjectForMockProjectDir(api.middlewareConfigFn),
-            entities: api.entities?.map(ctx.entityRefParser),
-            httpRoute: [api.method, api.path],
-            auth: api.auth,
+            declType: "Api",
+            declName: getRefObjectDeclarationName(api.fn),
+            declValue: {
+                fn: mapRefObjectForMockProjectDir(api.fn),
+                middlewareConfigFn: api.middlewareConfigFn &&
+                    mapRefObjectForMockProjectDir(api.middlewareConfigFn),
+                entities: api.entities?.map(ctx.resolveEntityRef),
+                httpRoute: [api.method, api.path],
+                auth: api.auth,
+            },
         });
     }
 });
@@ -592,10 +612,14 @@ describe("mapApiNamespace", () => {
     });
     function testMapApiNamespace(apiNamespace) {
         const ctx = makeMapperContext();
-        const result = AppSpecMapper.mapApiNamespace(apiNamespace, ctx);
+        const result = SpecElementMapper.mapApiNamespaceSpec(apiNamespace, ctx);
         expect(result).toStrictEqual({
-            middlewareConfigFn: mapRefObjectForMockProjectDir(apiNamespace.middlewareConfigFn),
-            path: apiNamespace.path,
+            declType: "ApiNamespace",
+            declName: getRefObjectDeclarationName(apiNamespace.middlewareConfigFn),
+            declValue: {
+                middlewareConfigFn: mapRefObjectForMockProjectDir(apiNamespace.middlewareConfigFn),
+                path: apiNamespace.path,
+            },
         });
     }
 });
@@ -711,19 +735,23 @@ describe("mapJob", () => {
     test("should throw if entity ref is not provided", () => {
         const job = Fixtures.getJob("full");
         const ctx = makeMapperContext({ entityNames: [] });
-        expect(() => AppSpecMapper.mapJob(job, ctx)).toThrow();
+        expect(() => SpecElementMapper.mapJobSpec(job, ctx)).toThrow();
     });
     function testMapJob(job) {
         const ctx = makeMapperContext({ entityNames: job.entities ?? [] });
-        const result = AppSpecMapper.mapJob(job, ctx);
+        const result = SpecElementMapper.mapJobSpec(job, ctx);
         expect(result).toStrictEqual({
-            executor: job.executor,
-            perform: {
-                fn: mapRefObjectForMockProjectDir(job.fn),
-                executorOptions: job.performExecutorOptions,
+            declType: "Job",
+            declName: getRefObjectDeclarationName(job.fn),
+            declValue: {
+                executor: job.executor,
+                perform: {
+                    fn: mapRefObjectForMockProjectDir(job.fn),
+                    executorOptions: job.performExecutorOptions,
+                },
+                schedule: job.schedule && SpecElementMapper.mapSchedule(job.schedule),
+                entities: job.entities?.map(ctx.resolveEntityRef),
             },
-            schedule: job.schedule && AppSpecMapper.mapSchedule(job.schedule),
-            entities: job.entities?.map(ctx.entityRefParser),
         });
     }
 });
@@ -737,14 +765,18 @@ describe("mapCrud", () => {
     test("should throw if entity ref is not provided", () => {
         const crudDecl = Fixtures.getCrud("full");
         const ctx = makeMapperContext({ entityNames: [] });
-        expect(() => AppSpecMapper.mapCrud(crudDecl, ctx)).toThrow();
+        expect(() => SpecElementMapper.mapCrudSpec(crudDecl, ctx)).toThrow();
     });
     function testMapCrud(crudDecl) {
         const ctx = makeMapperContext({ entityNames: [crudDecl.entity] });
-        const result = AppSpecMapper.mapCrud(crudDecl, ctx);
+        const result = SpecElementMapper.mapCrudSpec(crudDecl, ctx);
         expect(result).toStrictEqual({
-            entity: ctx.entityRefParser(crudDecl.entity),
-            operations: AppSpecMapper.mapCrudOperations(crudDecl.operations, ctx),
+            declType: "Crud",
+            declName: crudDecl.name,
+            declValue: {
+                entity: ctx.resolveEntityRef(crudDecl.entity),
+                operations: SpecElementMapper.mapCrudOperations(crudDecl.operations, ctx),
+            },
         });
     }
 });
@@ -757,18 +789,18 @@ describe("mapCrudOperations", () => {
     });
     function testMapCrudOperations(crudOperations) {
         const ctx = makeMapperContext();
-        const result = AppSpecMapper.mapCrudOperations(crudOperations, ctx);
+        const result = SpecElementMapper.mapCrudOperations(crudOperations, ctx);
         expect(result).toStrictEqual({
             get: crudOperations.get &&
-                AppSpecMapper.mapCrudOperationOptions(crudOperations.get, ctx),
+                SpecElementMapper.mapCrudOperationOptions(crudOperations.get, ctx),
             getAll: crudOperations.getAll &&
-                AppSpecMapper.mapCrudOperationOptions(crudOperations.getAll, ctx),
+                SpecElementMapper.mapCrudOperationOptions(crudOperations.getAll, ctx),
             create: crudOperations.create &&
-                AppSpecMapper.mapCrudOperationOptions(crudOperations.create, ctx),
+                SpecElementMapper.mapCrudOperationOptions(crudOperations.create, ctx),
             update: crudOperations.update &&
-                AppSpecMapper.mapCrudOperationOptions(crudOperations.update, ctx),
+                SpecElementMapper.mapCrudOperationOptions(crudOperations.update, ctx),
             delete: crudOperations.delete &&
-                AppSpecMapper.mapCrudOperationOptions(crudOperations.delete, ctx),
+                SpecElementMapper.mapCrudOperationOptions(crudOperations.delete, ctx),
         });
     }
 });
@@ -781,7 +813,7 @@ describe("mapCrudOperationOptions", () => {
     });
     function testMapCrudOperationOptions(crudOperationOptions) {
         const ctx = makeMapperContext();
-        const result = AppSpecMapper.mapCrudOperationOptions(crudOperationOptions, ctx);
+        const result = SpecElementMapper.mapCrudOperationOptions(crudOperationOptions, ctx);
         expect(result).toStrictEqual({
             isPublic: crudOperationOptions.isPublic,
             overrideFn: crudOperationOptions.overrideFn &&
@@ -797,7 +829,7 @@ describe("mapSchedule", () => {
         testMapSchedule(Fixtures.getSchedule("full"));
     });
     function testMapSchedule(schedule) {
-        const result = AppSpecMapper.mapSchedule(schedule);
+        const result = SpecElementMapper.mapSchedule(schedule);
         expect(result).toStrictEqual({
             cron: schedule.cron,
             args: schedule.args,

package/data/packages/spec/dist/__tests__/spec/normalizePrerender.unit.test.d.ts

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

package/data/packages/spec/dist/__tests__/spec/normalizePrerender.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizePrerender.unit.test.d.ts","sourceRoot":"","sources":["../../../__tests__/spec/normalizePrerender.unit.test.ts"],"names":[],"mappings":""}

package/data/packages/spec/dist/__tests__/spec/normalizePrerender.unit.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, test } from "vitest";
+import { normalizePrerender } from "../../src/normalizePrerender.js";
+describe("normalizePrerender", () => {
+    test("returns an empty list when prerendering is disabled", () => {
+        expect(normalizePrerender(undefined, "/foo")).toEqual([]);
+        expect(normalizePrerender(false, "/foo")).toEqual([]);
+        expect(normalizePrerender([], "/foo")).toEqual([]);
+    });
+    test("expands `true` to the route's own path", () => {
+        expect(normalizePrerender(true, "/foo")).toEqual(["/foo"]);
+    });
+    test("keeps an explicit list of paths as-is", () => {
+        expect(normalizePrerender(["/a", "/b"], "/foo")).toEqual(["/a", "/b"]);
+    });
+});

package/data/packages/spec/dist/__tests__/spec/refObject.unit.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "vitest";
 import { mapRefObject } from "../../src/spec/refObject.js";
-import { SpecUserError } from "../../src/spec/specUserError.js";
+import { WaspSpecUserError } from "../../src/spec/waspSpecUserError.js";
 import * as Fixtures from "./testFixtures.js";
 describe("mapRefObject", () => {
     test("should map minimal named import correctly", () => {
@@ -20,7 +20,7 @@ describe("mapRefObject", () => {
         { refObject: { parse: () => ({}) } },
         { refObject: { from: "./src/external" } },
     ])("returns an error for invalid runtime values", ({ refObject }) => {
-        expect(() => mapRefObjectForProject(refObject)).toThrow(SpecUserError);
+        expect(() => mapRefObjectForProject(refObject)).toThrow(WaspSpecUserError);
         expect(() => mapRefObjectForProject(refObject)).toThrow("Got an import in the Wasp file that we couldn't process");
     });
     function testMapRefObject(refObject) {

package/data/packages/spec/dist/__tests__/spec/refObjectPath.unit.test.js

@@ -55,7 +55,7 @@ import * as os from "node:os";
 import * as path from "node:path/posix"; // Module paths are always `/`-delimited
 import { describe, expect, test } from "vitest";
 import { normalizeRefObjectPath } from "../../src/spec/refObjectPath.js";
-import { SpecUserError } from "../../src/spec/specUserError.js";
+import { WaspSpecUserError } from "../../src/spec/waspSpecUserError.js";
 describe("normalizeRefObjectPath", () => {
     test("maps a top-level spec ref import targeting src", () => {
         const env_1 = { stack: [], error: void 0, hasError: false };
@@ -137,7 +137,7 @@ describe("normalizeRefObjectPath", () => {
                 importPath: "./helpers/helper",
                 importingFilePath: path.join(project.rootDir, "main.wasp.ts"),
                 projectRootDir: project.rootDir,
-            })).toThrow(SpecUserError);
+            })).toThrow(WaspSpecUserError);
             expect(() => normalizeRefObjectPath({
                 importPath: "./helpers/helper",
                 importingFilePath: path.join(project.rootDir, "main.wasp.ts"),
@@ -160,7 +160,7 @@ describe("normalizeRefObjectPath", () => {
                 importPath: "./src",
                 importingFilePath: path.join(project.rootDir, "main.wasp.ts"),
                 projectRootDir: project.rootDir,
-            })).toThrow(SpecUserError);
+            })).toThrow(WaspSpecUserError);
             expect(() => normalizeRefObjectPath({
                 importPath: "./src",
                 importingFilePath: path.join(project.rootDir, "main.wasp.ts"),