@wasp.sh/wasp-cli-darwin-arm64-unknown 0.23.0 → 0.24.0-rc.2

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

@@ -0,0 +1,814 @@
+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 { 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,
+    };
+}
+function mapMockApp(app, entityNames) {
+    return AppSpecMapper.mapApp(app, {
+        entityNames,
+        projectRootDir: Fixtures.MOCK_PROJECT_DIR,
+    });
+}
+describe("mapApp", () => {
+    test("should map minimal app correctly", () => {
+        const entityNames = Fixtures.getEntities("minimal");
+        const app = Fixtures.getApp("minimal");
+        const decls = mapMockApp(app, entityNames);
+        expect(decls).toStrictEqual([
+            {
+                declType: "App",
+                declName: app.name,
+                declValue: {
+                    wasp: app.wasp,
+                    title: app.title,
+                    head: app.head,
+                    auth: undefined,
+                    server: undefined,
+                    client: undefined,
+                    db: undefined,
+                    emailSender: undefined,
+                    webSocket: undefined,
+                },
+            },
+        ]);
+    });
+    test("should map full app correctly", () => {
+        // Note: we build the full app inline (instead of using `Fixtures.getApp("full")`)
+        // so the assertions can name each part explicitly when computing expected decls.
+        const page = Fixtures.getPage("full");
+        const route = Fixtures.getRoute("full");
+        const query = Fixtures.getQuery("full");
+        const api = Fixtures.getApi("full");
+        const apiNamespace = Fixtures.getApiNamespace("full");
+        const job = Fixtures.getJob("full");
+        const crud = Fixtures.getCrud("full");
+        const emailVerifyRoute = Fixtures.getEmailVerifyRoute();
+        const passwordResetRoute = Fixtures.getPasswordResetRoute();
+        const authConfig = Fixtures.getAuthConfig("full");
+        const server = Fixtures.getServerConfig("full");
+        const client = Fixtures.getClientConfig("full");
+        const db = Fixtures.getDbConfig("full");
+        const emailSender = Fixtures.getEmailSenderConfig("full");
+        const webSocket = Fixtures.getWebSocketConfig("full");
+        const entityNames = Fixtures.getEntities("full");
+        const inputApp = app({
+            name: "FullApp",
+            wasp: { version: "^0.16.3" },
+            title: "Mock App",
+            head: ['<link rel="icon" href="/favicon.ico" />'],
+            auth: authConfig,
+            server,
+            client,
+            db,
+            emailSender,
+            webSocket,
+            spec: [
+                page,
+                route,
+                query,
+                api,
+                apiNamespace,
+                job,
+                crud,
+                emailVerifyRoute,
+                passwordResetRoute,
+            ],
+        });
+        const result = mapMockApp(inputApp, entityNames);
+        const ctx = makeMapperContext({
+            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.
+        expect(result).toStrictEqual([
+            {
+                declType: "App",
+                declName: inputApp.name,
+                declValue: {
+                    wasp: inputApp.wasp,
+                    title: inputApp.title,
+                    head: inputApp.head,
+                    auth: AppSpecMapper.mapAuth(authConfig, ctx),
+                    server: AppSpecMapper.mapServer(server, ctx),
+                    client: AppSpecMapper.mapClient(client, ctx),
+                    db: AppSpecMapper.mapDb(db, ctx),
+                    emailSender: AppSpecMapper.mapEmailSender(emailSender),
+                    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),
+            },
+        ]);
+    });
+    test("dedups a page referenced explicitly twice", () => {
+        const refObject = Fixtures.getRefObject("minimal", "default");
+        const pageName = getRefObjectDeclarationName(refObject);
+        const page1 = page(refObject);
+        const page2 = page(refObject);
+        const app = Fixtures.getMinimalAppWithSpec([page1, page2]);
+        const decls = mapMockApp(app, []);
+        const pageNames = decls
+            .filter((d) => d.declType === "Page")
+            .map((d) => d.declName);
+        expect(pageNames).toEqual([pageName]);
+    });
+    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 page2 = page(refObject);
+        const route1 = route("Route1", "/", page1);
+        const route2 = route("Route2", "/", page2);
+        const app = Fixtures.getMinimalAppWithSpec([route1, route2]);
+        const decls = mapMockApp(app, []);
+        const pageNames = decls
+            .filter((d) => d.declType === "Page")
+            .map((d) => d.declName);
+        expect(pageNames).toEqual([pageName]);
+    });
+    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 page2 = page(refObject);
+        const route1 = route("Route1", "/", page2);
+        const app = Fixtures.getMinimalAppWithSpec([page1, route1]);
+        const decls = mapMockApp(app, []);
+        const pageNames = decls
+            .filter((d) => d.declType === "Page")
+            .map((d) => d.declName);
+        expect(pageNames).toEqual([pageName]);
+    });
+    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 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 page2 = page(refObject, { authRequired: true });
+        const route1 = route("Route1", "/", page1);
+        const route2 = route("Route2", "/", page2);
+        const app = Fixtures.getMinimalAppWithSpec([route1, route2]);
+        expect(() => mapMockApp(app, [])).toThrow(`Conflicting configurations for the page \`${pageName}\``);
+    });
+    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 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.
+});
+describe("mapPage", () => {
+    test("should map minimal config correctly", () => {
+        testMapPage(Fixtures.getPage("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapPage(Fixtures.getPage("full"));
+    });
+    function testMapPage(page) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapPage(page, ctx);
+        expect(result).toStrictEqual({
+            component: mapRefObjectForMockProjectDir(page.component),
+            authRequired: page.authRequired,
+        });
+    }
+});
+describe("mapRoute", () => {
+    test("should map minimal config correctly", () => {
+        testMapRoute(Fixtures.getRoute("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapRoute(Fixtures.getRoute("full"));
+    });
+    function testMapRoute(route) {
+        const result = AppSpecMapper.mapRoute(route);
+        expect(result).toStrictEqual({
+            path: route.path,
+            to: {
+                name: getRefObjectDeclarationName(route.page.component),
+                declType: "Page",
+            },
+            prerender: route.prerender,
+            lazy: route.lazy,
+        });
+    }
+});
+describe("mapQuery", () => {
+    test("should map minimal config correctly", () => {
+        testMapQuery(Fixtures.getQuery("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapQuery(Fixtures.getQuery("full"));
+    });
+    test("should throw if entity ref is not provided", () => {
+        const query = Fixtures.getQuery("full");
+        const ctx = makeMapperContext({ entityNames: [] });
+        expect(() => AppSpecMapper.mapQuery(query, ctx)).toThrow();
+    });
+    function testMapQuery(query) {
+        const ctx = makeMapperContext({ entityNames: query.entities ?? [] });
+        const result = AppSpecMapper.mapQuery(query, ctx);
+        expect(result).toStrictEqual({
+            fn: mapRefObjectForMockProjectDir(query.fn),
+            entities: query.entities?.map(ctx.entityRefParser),
+            auth: query.auth,
+        });
+    }
+});
+describe("mapAction", () => {
+    test("should map minimal config correctly", () => {
+        testMapAction(Fixtures.getAction("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapAction(Fixtures.getAction("full"));
+    });
+    test("should throw if entity ref is not provided", () => {
+        const action = Fixtures.getAction("full");
+        const ctx = makeMapperContext({ entityNames: [] });
+        expect(() => AppSpecMapper.mapAction(action, ctx)).toThrow();
+    });
+    function testMapAction(action) {
+        const ctx = makeMapperContext({ entityNames: action.entities ?? [] });
+        const result = AppSpecMapper.mapAction(action, ctx);
+        expect(result).toStrictEqual({
+            fn: mapRefObjectForMockProjectDir(action.fn),
+            entities: action.entities?.map(ctx.entityRefParser),
+            auth: action.auth,
+        });
+    }
+});
+describe("mapAuth", () => {
+    test("should map minimal config correctly", () => {
+        testMapAuth(Fixtures.getAuthConfig("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapAuth(Fixtures.getAuthConfig("full"));
+    });
+    test("should throw if userEntity is not provided to entity parser", () => {
+        testMapAuth(Fixtures.getAuthConfig("minimal"), {
+            overrideEntities: [],
+            shouldError: true,
+        });
+    });
+    test("should throw if emailVerification clientRoute ref is not provided when defined", () => {
+        const auth = Fixtures.getAuthConfig("full");
+        assertDefined(auth.methods.email?.emailVerification.clientRoute);
+        testMapAuth(auth, {
+            overrideRoutes: [auth.methods.email.passwordReset.clientRoute],
+            shouldError: true,
+        });
+    });
+    test("should throw if passwordReset clientRoute ref is not provided when defined", () => {
+        const auth = Fixtures.getAuthConfig("full");
+        assertDefined(auth.methods.email?.passwordReset.clientRoute);
+        testMapAuth(auth, {
+            overrideRoutes: [auth.methods.email.emailVerification.clientRoute],
+            shouldError: true,
+        });
+    });
+    function testMapAuth(auth, options = {
+        shouldError: false,
+    }) {
+        const { overrideEntities, overrideRoutes, shouldError } = options;
+        const entities = overrideEntities ?? [auth.userEntity];
+        const routes = overrideRoutes ??
+            [
+                auth.methods.email?.emailVerification.clientRoute,
+                auth.methods.email?.passwordReset.clientRoute,
+            ].filter((e) => e !== undefined);
+        const ctx = makeMapperContext({
+            entityNames: entities,
+            routeNames: routes,
+        });
+        if (shouldError) {
+            expect(() => AppSpecMapper.mapAuth(auth, ctx)).toThrow();
+            return;
+        }
+        const result = AppSpecMapper.mapAuth(auth, ctx);
+        expect(result).toStrictEqual({
+            userEntity: ctx.entityRefParser(auth.userEntity),
+            methods: AppSpecMapper.mapAuthMethods(auth.methods, ctx),
+            onAuthFailedRedirectTo: auth.onAuthFailedRedirectTo,
+            onAuthSucceededRedirectTo: auth.onAuthSucceededRedirectTo,
+            onBeforeSignup: auth.onBeforeSignup &&
+                mapRefObjectForMockProjectDir(auth.onBeforeSignup),
+            onAfterSignup: auth.onAfterSignup && mapRefObjectForMockProjectDir(auth.onAfterSignup),
+            onAfterEmailVerified: auth.onAfterEmailVerified &&
+                mapRefObjectForMockProjectDir(auth.onAfterEmailVerified),
+            onBeforeOAuthRedirect: auth.onBeforeOAuthRedirect &&
+                mapRefObjectForMockProjectDir(auth.onBeforeOAuthRedirect),
+            onBeforeLogin: auth.onBeforeLogin && mapRefObjectForMockProjectDir(auth.onBeforeLogin),
+            onAfterLogin: auth.onAfterLogin && mapRefObjectForMockProjectDir(auth.onAfterLogin),
+        });
+    }
+});
+describe("mapAuthMethods", () => {
+    test("should map minimal config correctly", () => {
+        testMapAuthMethods(Fixtures.getAuthMethods("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapAuthMethods(Fixtures.getAuthMethods("full"));
+    });
+    test("should throw if emailVerification clientRoute ref is not provided when defined", () => {
+        const authMethods = Fixtures.getAuthMethods("full");
+        assertDefined(authMethods.email?.emailVerification.clientRoute);
+        testMapAuthMethods(authMethods, {
+            overrideRoutes: [authMethods.email.passwordReset.clientRoute],
+            shouldError: true,
+        });
+    });
+    test("should throw if passwordReset clientRoute ref is not provided when defined", () => {
+        const authMethods = Fixtures.getAuthMethods("full");
+        assertDefined(authMethods.email?.passwordReset.clientRoute);
+        testMapAuthMethods(authMethods, {
+            overrideRoutes: [authMethods.email.emailVerification.clientRoute],
+            shouldError: true,
+        });
+    });
+    function testMapAuthMethods(authMethods, options = {
+        shouldError: false,
+    }) {
+        const { overrideRoutes, shouldError } = options;
+        const routes = overrideRoutes ??
+            [
+                authMethods.email?.emailVerification.clientRoute,
+                authMethods.email?.passwordReset.clientRoute,
+            ].filter((e) => e !== undefined);
+        const ctx = makeMapperContext({ routeNames: routes });
+        if (shouldError) {
+            expect(() => AppSpecMapper.mapAuthMethods(authMethods, ctx)).toThrow();
+            return;
+        }
+        const result = AppSpecMapper.mapAuthMethods(authMethods, ctx);
+        expect(result).toStrictEqual({
+            usernameAndPassword: authMethods.usernameAndPassword &&
+                AppSpecMapper.mapUsernameAndPassword(authMethods.usernameAndPassword, ctx),
+            slack: authMethods.slack &&
+                AppSpecMapper.mapSocialAuth(authMethods.slack, ctx),
+            discord: authMethods.discord &&
+                AppSpecMapper.mapSocialAuth(authMethods.discord, ctx),
+            google: authMethods.google &&
+                AppSpecMapper.mapSocialAuth(authMethods.google, ctx),
+            gitHub: authMethods.gitHub &&
+                AppSpecMapper.mapSocialAuth(authMethods.gitHub, ctx),
+            keycloak: authMethods.keycloak &&
+                AppSpecMapper.mapSocialAuth(authMethods.keycloak, ctx),
+            microsoft: authMethods.microsoft &&
+                AppSpecMapper.mapSocialAuth(authMethods.microsoft, ctx),
+            email: authMethods.email && AppSpecMapper.mapEmailAuth(authMethods.email, ctx),
+        });
+    }
+});
+describe("mapEmailAuth", () => {
+    test("should map minimal config correctly", () => {
+        testMapEmailAuth(Fixtures.getEmailAuthConfig("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapEmailAuth(Fixtures.getEmailAuthConfig("full"));
+    });
+    test("should throw if emailVerification clientRoute ref is not provided when defined", () => {
+        const emailAuth = Fixtures.getEmailAuthConfig("full");
+        expect(emailAuth.emailVerification.clientRoute).toBeDefined();
+        testMapEmailAuth(emailAuth, {
+            overrideRoutes: [emailAuth.passwordReset.clientRoute],
+            shouldError: true,
+        });
+    });
+    test("should throw if passwordReset clientRoute ref is not provided when defined", () => {
+        const emailAuth = Fixtures.getEmailAuthConfig("full");
+        expect(emailAuth.passwordReset.clientRoute).toBeDefined();
+        testMapEmailAuth(emailAuth, {
+            overrideRoutes: [emailAuth.emailVerification.clientRoute],
+            shouldError: true,
+        });
+    });
+    function testMapEmailAuth(emailAuth, options = {
+        shouldError: false,
+    }) {
+        const { overrideRoutes, shouldError } = options;
+        const routes = overrideRoutes ??
+            [
+                emailAuth?.emailVerification.clientRoute,
+                emailAuth?.passwordReset.clientRoute,
+            ].filter((e) => e !== undefined);
+        const ctx = makeMapperContext({ routeNames: routes });
+        if (shouldError) {
+            expect(() => AppSpecMapper.mapEmailAuth(emailAuth, ctx)).toThrow();
+            return;
+        }
+        const result = AppSpecMapper.mapEmailAuth(emailAuth, ctx);
+        expect(result).toStrictEqual({
+            userSignupFields: emailAuth.userSignupFields &&
+                mapRefObjectForMockProjectDir(emailAuth.userSignupFields),
+            fromField: AppSpecMapper.mapEmailFromField(emailAuth.fromField),
+            emailVerification: AppSpecMapper.mapEmailFlow(emailAuth.emailVerification, ctx),
+            passwordReset: AppSpecMapper.mapEmailFlow(emailAuth.passwordReset, ctx),
+        });
+    }
+});
+describe("mapEmailFlow", () => {
+    test("should map minimal email verification config correctly", () => {
+        testMapEmailFlow(Fixtures.getEmailVerificationConfig("minimal"));
+    });
+    test("should map full email verification config correctly", () => {
+        testMapEmailFlow(Fixtures.getEmailVerificationConfig("full"));
+    });
+    test("should map minimal password reset config correctly", () => {
+        testMapEmailFlow(Fixtures.getPasswordResetConfig("minimal"));
+    });
+    test("should map full password reset config correctly", () => {
+        testMapEmailFlow(Fixtures.getPasswordResetConfig("full"));
+    });
+    test("should throw if clientRoute ref is not provided when defined", () => {
+        const emailFlow = Fixtures.getEmailVerificationConfig("full");
+        expect(emailFlow.clientRoute).toBeDefined();
+        testMapEmailFlow(emailFlow, {
+            overrideRoutes: [],
+            shouldError: true,
+        });
+    });
+    function testMapEmailFlow(emailFlow, options = {
+        shouldError: false,
+    }) {
+        const { overrideRoutes, shouldError } = options;
+        const routes = overrideRoutes ?? [emailFlow.clientRoute];
+        const ctx = makeMapperContext({ routeNames: routes });
+        if (shouldError) {
+            expect(() => AppSpecMapper.mapEmailFlow(emailFlow, ctx)).toThrow();
+            return;
+        }
+        const result = AppSpecMapper.mapEmailFlow(emailFlow, ctx);
+        expect(result).toStrictEqual({
+            clientRoute: ctx.routeRefParser(emailFlow.clientRoute),
+            getEmailContentFn: emailFlow.getEmailContentFn &&
+                mapRefObjectForMockProjectDir(emailFlow.getEmailContentFn),
+        });
+    }
+});
+describe("mapUsernameAndPassword", () => {
+    test("should map minimal config correctly", () => {
+        testMapUsernameAndPassword(Fixtures.getUsernameAndPasswordConfig("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapUsernameAndPassword(Fixtures.getUsernameAndPasswordConfig("full"));
+    });
+    function testMapUsernameAndPassword(usernameAndPassword) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapUsernameAndPassword(usernameAndPassword, ctx);
+        expect(result).toStrictEqual({
+            userSignupFields: usernameAndPassword.userSignupFields &&
+                mapRefObjectForMockProjectDir(usernameAndPassword.userSignupFields),
+        });
+    }
+});
+describe("mapSocialAuth", () => {
+    test("should map minimal config correctly", () => {
+        testMapSocialAuth(Fixtures.getSocialAuthConfig("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapSocialAuth(Fixtures.getSocialAuthConfig("full"));
+    });
+    function testMapSocialAuth(socialAuth) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapSocialAuth(socialAuth, ctx);
+        expect(result).toStrictEqual({
+            configFn: socialAuth.configFn &&
+                mapRefObjectForMockProjectDir(socialAuth.configFn),
+            userSignupFields: socialAuth.userSignupFields &&
+                mapRefObjectForMockProjectDir(socialAuth.userSignupFields),
+        });
+    }
+});
+describe("mapApi", () => {
+    test("should map minimal config correctly", () => {
+        testMapApi(Fixtures.getApi("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapApi(Fixtures.getApi("full"));
+    });
+    test("should throw if entity refs are not provided", () => {
+        const api = Fixtures.getApi("full");
+        const ctx = makeMapperContext({ entityNames: [] });
+        expect(() => AppSpecMapper.mapApi(api, ctx)).toThrow();
+    });
+    function testMapApi(api) {
+        const ctx = makeMapperContext({ entityNames: api.entities ?? [] });
+        const result = AppSpecMapper.mapApi(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,
+        });
+    }
+});
+describe("mapApiNamespace", () => {
+    test("should map minimal config correctly", () => {
+        testMapApiNamespace(Fixtures.getApiNamespace("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapApiNamespace(Fixtures.getApiNamespace("full"));
+    });
+    function testMapApiNamespace(apiNamespace) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapApiNamespace(apiNamespace, ctx);
+        expect(result).toStrictEqual({
+            middlewareConfigFn: mapRefObjectForMockProjectDir(apiNamespace.middlewareConfigFn),
+            path: apiNamespace.path,
+        });
+    }
+});
+describe("mapServer", () => {
+    test("should map minimal config correctly", () => {
+        testMapServer(Fixtures.getServerConfig("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapServer(Fixtures.getServerConfig("full"));
+    });
+    function testMapServer(server) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapServer(server, ctx);
+        expect(result).toStrictEqual({
+            setupFn: server.setupFn && mapRefObjectForMockProjectDir(server.setupFn),
+            middlewareConfigFn: server.middlewareConfigFn &&
+                mapRefObjectForMockProjectDir(server.middlewareConfigFn),
+            envValidationSchema: server.envValidationSchema &&
+                mapRefObjectForMockProjectDir(server.envValidationSchema),
+        });
+    }
+});
+describe("mapClient", () => {
+    test("should map minimal config correctly", () => {
+        testMapClient(Fixtures.getClientConfig("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapClient(Fixtures.getClientConfig("full"));
+    });
+    function testMapClient(client) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapClient(client, ctx);
+        expect(result).toStrictEqual({
+            rootComponent: client.rootComponent &&
+                mapRefObjectForMockProjectDir(client.rootComponent),
+            setupFn: client.setupFn && mapRefObjectForMockProjectDir(client.setupFn),
+            baseDir: client.baseDir,
+            envValidationSchema: client.envValidationSchema &&
+                mapRefObjectForMockProjectDir(client.envValidationSchema),
+        });
+    }
+});
+describe("mapDb", () => {
+    test("should map minimal config correctly", () => {
+        testMapDb(Fixtures.getDbConfig("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapDb(Fixtures.getDbConfig("full"));
+    });
+    function testMapDb(db) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapDb(db, ctx);
+        expect(result).toStrictEqual({
+            seeds: db.seeds?.map((seed) => mapRefObjectForMockProjectDir(seed)),
+            prismaSetupFn: db.prismaSetupFn && mapRefObjectForMockProjectDir(db.prismaSetupFn),
+        });
+    }
+});
+describe("mapEmailSender", () => {
+    test("should map minimal config correctly", () => {
+        testMapEmailSender(Fixtures.getEmailSenderConfig("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapEmailSender(Fixtures.getEmailSenderConfig("full"));
+    });
+    function testMapEmailSender(emailSender) {
+        const result = AppSpecMapper.mapEmailSender(emailSender);
+        expect(result).toStrictEqual({
+            provider: emailSender.provider,
+            defaultFrom: emailSender.defaultFrom &&
+                AppSpecMapper.mapEmailFromField(emailSender.defaultFrom),
+        });
+    }
+});
+describe("mapEmailFromField", () => {
+    test("should map minimal config correctly", () => {
+        testMapEmailFromField(Fixtures.getEmailFromField("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapEmailFromField(Fixtures.getEmailFromField("full"));
+    });
+    function testMapEmailFromField(emailFromField) {
+        const result = AppSpecMapper.mapEmailFromField(emailFromField);
+        expect(result).toStrictEqual({
+            name: emailFromField.name,
+            email: emailFromField.email,
+        });
+    }
+});
+describe("mapWebSocket", () => {
+    test("should map minimal config correctly", () => {
+        testMapWebSocket(Fixtures.getWebSocketConfig("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapWebSocket(Fixtures.getWebSocketConfig("full"));
+    });
+    function testMapWebSocket(webSocket) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapWebSocket(webSocket, ctx);
+        expect(result).toStrictEqual({
+            fn: mapRefObjectForMockProjectDir(webSocket.fn),
+            autoConnect: webSocket.autoConnect,
+        });
+    }
+});
+describe("mapJob", () => {
+    test("should map minimal config correctly", () => {
+        testMapJob(Fixtures.getJob("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapJob(Fixtures.getJob("full"));
+    });
+    test("should throw if entity ref is not provided", () => {
+        const job = Fixtures.getJob("full");
+        const ctx = makeMapperContext({ entityNames: [] });
+        expect(() => AppSpecMapper.mapJob(job, ctx)).toThrow();
+    });
+    function testMapJob(job) {
+        const ctx = makeMapperContext({ entityNames: job.entities ?? [] });
+        const result = AppSpecMapper.mapJob(job, ctx);
+        expect(result).toStrictEqual({
+            executor: job.executor,
+            perform: {
+                fn: mapRefObjectForMockProjectDir(job.fn),
+                executorOptions: job.performExecutorOptions,
+            },
+            schedule: job.schedule && AppSpecMapper.mapSchedule(job.schedule),
+            entities: job.entities?.map(ctx.entityRefParser),
+        });
+    }
+});
+describe("mapCrud", () => {
+    test("should map minimal config correctly", () => {
+        testMapCrud(Fixtures.getCrud("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapCrud(Fixtures.getCrud("full"));
+    });
+    test("should throw if entity ref is not provided", () => {
+        const crudDecl = Fixtures.getCrud("full");
+        const ctx = makeMapperContext({ entityNames: [] });
+        expect(() => AppSpecMapper.mapCrud(crudDecl, ctx)).toThrow();
+    });
+    function testMapCrud(crudDecl) {
+        const ctx = makeMapperContext({ entityNames: [crudDecl.entity] });
+        const result = AppSpecMapper.mapCrud(crudDecl, ctx);
+        expect(result).toStrictEqual({
+            entity: ctx.entityRefParser(crudDecl.entity),
+            operations: AppSpecMapper.mapCrudOperations(crudDecl.operations, ctx),
+        });
+    }
+});
+describe("mapCrudOperations", () => {
+    test("should map minimal config correctly", () => {
+        testMapCrudOperations(Fixtures.getCrudOperations("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapCrudOperations(Fixtures.getCrudOperations("full"));
+    });
+    function testMapCrudOperations(crudOperations) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapCrudOperations(crudOperations, ctx);
+        expect(result).toStrictEqual({
+            get: crudOperations.get &&
+                AppSpecMapper.mapCrudOperationOptions(crudOperations.get, ctx),
+            getAll: crudOperations.getAll &&
+                AppSpecMapper.mapCrudOperationOptions(crudOperations.getAll, ctx),
+            create: crudOperations.create &&
+                AppSpecMapper.mapCrudOperationOptions(crudOperations.create, ctx),
+            update: crudOperations.update &&
+                AppSpecMapper.mapCrudOperationOptions(crudOperations.update, ctx),
+            delete: crudOperations.delete &&
+                AppSpecMapper.mapCrudOperationOptions(crudOperations.delete, ctx),
+        });
+    }
+});
+describe("mapCrudOperationOptions", () => {
+    test("should map minimal config correctly", () => {
+        testMapCrudOperationOptions(Fixtures.getCrudOperationOptions("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapCrudOperationOptions(Fixtures.getCrudOperationOptions("full"));
+    });
+    function testMapCrudOperationOptions(crudOperationOptions) {
+        const ctx = makeMapperContext();
+        const result = AppSpecMapper.mapCrudOperationOptions(crudOperationOptions, ctx);
+        expect(result).toStrictEqual({
+            isPublic: crudOperationOptions.isPublic,
+            overrideFn: crudOperationOptions.overrideFn &&
+                mapRefObjectForMockProjectDir(crudOperationOptions.overrideFn),
+        });
+    }
+});
+describe("mapSchedule", () => {
+    test("should map minimal config correctly", () => {
+        testMapSchedule(Fixtures.getSchedule("minimal"));
+    });
+    test("should map full config correctly", () => {
+        testMapSchedule(Fixtures.getSchedule("full"));
+    });
+    function testMapSchedule(schedule) {
+        const result = AppSpecMapper.mapSchedule(schedule);
+        expect(result).toStrictEqual({
+            cron: schedule.cron,
+            args: schedule.args,
+            executorOptions: schedule.executorOptions,
+        });
+    }
+});
+/**
+ * An `expect(value).toBeDefined()` assertion that also narrows the type of the
+ * variable.
+ */
+function assertDefined(value) {
+    expect(value).toBeDefined();
+}