@wasp.sh/wasp-cli-darwin-x64-unknown 0.25.0 → 0.26.0

package/data/Generator/templates/sdk/wasp/client/router/index.ts

@@ -1,27 +1,27 @@
 {{={= =}=}}
-import { interpolatePath } from './linkHelpers'
-import type {
-  RouteDefinitionsToRoutes,
-  OptionalRouteOptions,
-  ParamValue,
-  ExpandRouteOnOptionalStaticSegments,
-} from './types'
+import {
+  interpolatePath,
+  type RouteDefinitionsToRoutes,
+  type OptionalRouteOptions,
+  type ParamValue,
+  type ExpandRouteOnOptionalStaticSegments,
+} from '@wasp.sh/lib-sdk-core'
 
 // PUBLIC API
 export const routes = {
   {=# routes =}
   {= name =}: {
-    to: "{= urlPath =}",
+    to: {=& urlPath =},
     {=# hasUrlParams =}
     build: (
       options: OptionalRouteOptions
-      & { params: {{=# urlParams =}"{= name =}"{=# isOptional =}?{=/ isOptional =}: ParamValue;{=/ urlParams =}}}
+      & { params: {{=# urlParams =}{=& name =}{=# isOptional =}?{=/ isOptional =}: ParamValue;{=/ urlParams =}}}
       {=# hasOptionalStaticSegments =}
-      & { path: ExpandRouteOnOptionalStaticSegments<"{= urlPath =}"> }
+      & { path: ExpandRouteOnOptionalStaticSegments<{=& urlPath =}> }
       {=/ hasOptionalStaticSegments =}
     ) => interpolatePath(
         {=# hasOptionalStaticSegments =}options.path,{=/ hasOptionalStaticSegments =}
-        {=^ hasOptionalStaticSegments =}"{= urlPath =}",{=/ hasOptionalStaticSegments =}
+        {=^ hasOptionalStaticSegments =}{=& urlPath =},{=/ hasOptionalStaticSegments =}
         options.params,
         options?.search,
         options?.hash
@@ -32,11 +32,11 @@ export const routes = {
       options?:
       OptionalRouteOptions
       {=# hasOptionalStaticSegments =}
-      & { path: ExpandRouteOnOptionalStaticSegments<"{= urlPath =}"> }
+      & { path: ExpandRouteOnOptionalStaticSegments<{=& urlPath =}> }
       {=/ hasOptionalStaticSegments =}
     ) => interpolatePath(
         {=# hasOptionalStaticSegments =}options.path,{=/ hasOptionalStaticSegments =}
-        {=^ hasOptionalStaticSegments =}"{= urlPath =}",{=/ hasOptionalStaticSegments =}
+        {=^ hasOptionalStaticSegments =}{=& urlPath =},{=/ hasOptionalStaticSegments =}
         undefined,
         options?.search,
         options?.hash
@@ -50,6 +50,6 @@ export const routes = {
 export type Routes = RouteDefinitionsToRoutes<typeof routes>
 
 // PUBLIC API
-export { Link } from './Link'
+export { Link, type LinkProps } from './Link'
 // PUBLIC API
-export { NavLink } from './NavLink'
+export { NavLink, type NavLinkProps } from './NavLink'

package/data/Generator/templates/sdk/wasp/client/test/index.ts

@@ -1 +1,2 @@
-export { renderInContext, mockServer } from './vitest/helpers'
+export { renderInContext } from '@wasp.sh/lib-sdk-core/browser/test'
+export { mockServer } from './vitest/helpers'

package/data/Generator/templates/sdk/wasp/client/test/vitest/helpers.tsx

@@ -1,44 +1,11 @@
-import { ReactElement, ReactNode } from 'react'
+import type { MockQuery, MockApi } from '@wasp.sh/lib-sdk-core/browser/test'
 import { http, type HttpResponseResolver, type RequestHandler } from 'msw'
 import { setupServer, type SetupServer } from 'msw/node'
-import { BrowserRouter as Router } from 'react-router'
-import { render, RenderResult, cleanup } from '@testing-library/react'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { cleanup } from '@testing-library/react'
 import { beforeAll, afterEach, afterAll } from 'vitest'
-import { Query } from '../../operations/rpc.js'
-import { config, HttpMethod, Route } from '../../index.js'
+import { config, HttpMethod, type Route } from '../../index.js'
 import { serialize } from '../../../core/serialization/index.js'
 
-// PRIVATE API
-export type MockQuery = <Input, Output, MockOutput extends Output>(
-  query: Query<Input, Output>,
-  resJson: MockOutput
-) => void
-
-// PRIVATE API
-export type MockApi = (route: Route, resJson: unknown) => void
-
-// PUBLIC API
-// Inspired by the Tanstack React Query helper:
-// https://github.com/TanStack/query/blob/4ae99561ca3383d6de3f4aad656a49ba4a17b57a/packages/react-query/src/__tests__/utils.tsx#L7-L26
-export function renderInContext(ui: ReactElement): RenderResult {
-  const client = new QueryClient()
-  const { rerender, ...result } = render(
-    <QueryClientProvider client={client}>
-      <Router>{ui}</Router>
-    </QueryClientProvider>
-  )
-  return {
-    ...result,
-    rerender: (rerenderUi: ReactNode) =>
-      rerender(
-        <QueryClientProvider client={client}>
-          <Router>{rerenderUi}</Router>
-        </QueryClientProvider>
-      ),
-  }
-}
-
 // PUBLIC API
 export function mockServer(): {
   server: SetupServer
@@ -85,7 +52,9 @@ function mockRoute(
     [HttpMethod.Get]: http.get(url, responseHandler),
     [HttpMethod.Post]: http.post(url, responseHandler),
     [HttpMethod.Put]: http.put(url, responseHandler),
+    [HttpMethod.Patch]: http.patch(url, responseHandler),
     [HttpMethod.Delete]: http.delete(url, responseHandler),
+    [HttpMethod.Head]: http.head(url, responseHandler),
   }
 
   server.use(handlers[route.method])

package/data/Generator/templates/sdk/wasp/client/vite/index.ts

@@ -1 +1,2 @@
-export { type WaspPluginOptions, wasp } from "./plugins/wasp.js";
+export type { WaspPluginOptions } from '@wasp.sh/lib-sdk-core/node/vite'
+export { wasp } from "./plugins/wasp.js";

package/data/Generator/templates/sdk/wasp/client/vite/plugins/virtualUserModules.ts

@@ -0,0 +1,43 @@
+{{={= =}=}}
+import path from "node:path";
+import type { Plugin } from "vite";
+
+/**
+ * Maps virtual module IDs (pointing to user's client modules)
+ * to their relative import paths from the client project root.
+ * 
+ * @example
+ * clientVirtualUserModuleMap["virtual:wasp/user/env"] // => "./src/env"
+ */
+const clientVirtualUserModuleMap: { [virtualUserModule: string]: string } = {
+  {=# virtualUserModules =}
+  {=& virtualModuleId =}: {=& importJson.importPath =},
+  {=/ virtualUserModules =}
+};
+
+/**
+ * Resolves virtual modules pointing to user's modules.
+ * Virtual user modules allow Wasp code to depend on user code at runtime,
+ * without depending on the user's project during compile time.
+ */
+export function virtualUserModules(): Plugin {
+  let clientRootDir!: string;
+
+  return {
+    name: "wasp:virtual-user-modules",
+    enforce: "pre",
+    configResolved(config) {
+      clientRootDir = config.root;
+    },
+    async resolveId(id, importer, options) {
+      const userModulePath = Object.hasOwn(clientVirtualUserModuleMap, id)
+        ? clientVirtualUserModuleMap[id]
+        : undefined;
+      if (userModulePath !== undefined) {
+        const absPath = path.resolve(clientRootDir, userModulePath);
+        return this.resolve(absPath, importer, { ...options, skipSelf: true });
+      }
+      return null;
+    },
+  };
+}

package/data/Generator/templates/sdk/wasp/client/vite/plugins/{virtualModules.ts → virtualWaspModules.ts}

@@ -1,11 +1,11 @@
 {{={= =}=}}
-import { type Plugin } from "vite";
+import type { Plugin } from "vite";
 import {
   getClientEntryTsxContent,
   getRoutesTsxContent,
   getSsrEntryTsxContent,
 } from "../virtual-files/index.js";
-import { makeVirtualFilesResolver, type VirtualFiles } from "../virtual-files/resolver.js";
+import { makeVirtualFilesResolver, type VirtualFiles } from "@wasp.sh/lib-sdk-core/node/vite";
 
 const resolveVirtualFiles = makeVirtualFilesResolver([
   { id: "{= clientEntryPointPath =}", load: getClientEntryTsxContent },
@@ -13,11 +13,11 @@ const resolveVirtualFiles = makeVirtualFilesResolver([
   { id: "{= ssrEntryPointPath =}", load: getSsrEntryTsxContent },
 ]);
 
-export function waspVirtualModules(): Plugin {
+export function virtualWaspModules(): Plugin {
   let virtualFiles!: VirtualFiles;
 
   return {
-    name: "wasp:virtual-modules",
+    name: "wasp:virtual-wasp-modules",
     enforce: "pre",
     configResolved(config) {
       virtualFiles = resolveVirtualFiles(config.root);

package/data/Generator/templates/sdk/wasp/client/vite/plugins/wasp.ts

@@ -1,17 +1,19 @@
 {{={= =}=}}
-import { type PluginOption } from "vite";
-import react, { type Options as ReactOptions } from "@vitejs/plugin-react";
+import type { PluginOption } from "vite";
+import react from "@vitejs/plugin-react";
+import {
+  detectServerImports,
+  envFile,
+  typescriptCheck,
+  validateEnv,
+  type WaspPluginOptions,
+} from "@wasp.sh/lib-sdk-core/node/vite";
 import ssr from "@wasp.sh/lib-vite-ssr";
-import { validateEnv } from "./validateEnv.js";
-import { envFile } from "./envFile.js";
-import { detectServerImports } from "./detectServerImports.js";
-import { waspVirtualModules } from "./virtualModules.js";
-import { typescriptCheck } from "./typescriptCheck.js";
+import { virtualWaspModules } from "./virtualWaspModules.js";
+import { virtualUserModules } from "./virtualUserModules.js";
 import { waspConfig } from "./waspConfig.js";
 
-export interface WaspPluginOptions {
-  reactOptions?: ReactOptions;
-}
+
 
 export function wasp(options?: WaspPluginOptions): PluginOption {
   return [
@@ -21,14 +23,15 @@ export function wasp(options?: WaspPluginOptions): PluginOption {
     // The `wasp:config` plugin must come first because
     // other plugins may depend on its configuration.
     waspConfig(),
-    waspVirtualModules(),
-    envFile(),
-    detectServerImports(),
+    virtualUserModules(),
+    virtualWaspModules(),
+    envFile("{= clientEnvFileName =}"),
+    detectServerImports("{= srcDirInWaspProjectDir =}"),
     /**
      * Plugins running after core Vite plugins.
      */
     typescriptCheck({ srcTsConfigPath: "{= srcTsConfigPath =}" }),
-    validateEnv(),
+    validateEnv("{= clientEnvSchemaValidationModulePath =}"),
     react(options?.reactOptions),
     ssr({
       clientEntrySrc: "{= clientEntryPointPath =}",

package/data/Generator/templates/sdk/wasp/client/vite/plugins/waspConfig.ts

@@ -1,52 +1,80 @@
 {{={= =}=}}
 /// <reference types="vitest/config" />
-import { type PluginOption } from "vite";
-import { defaultExclude } from "vitest/config"
+import type { PluginOption } from "vite";
+import { defaultExclude } from "vitest/config";
 
 // Vite merges `userConfig` and our `waspConfig` returned from the plugin.
 // In that merge, primitive values from waspConfig take precedence, and
 // arrays are concatenated.
 //
 // This allows us to treat config values differently:
-//  - Forced: hardcoded in the return object so they always win. If the
-//    user set one of these in their vite.config.ts, we throw an error.
+//  - Forced: taken from `forcedOptions` in the return object so they
+//    always win. If the user set one of these in their vite.config.ts,
+//    we throw an error.
 //  - Overridable: we read the user's value and use it or fall back to
 //    our default.
 //  - Additive (arrays): we only return Wasp's entries; Vite's merge
 //    appends them to whatever the user already has.
 
 const forcedOptions = {
-  'base': "{= baseDir =}",
-  'envPrefix': "REACT_APP_",
-  'build.outDir': "{= clientBuildDirPath =}",
+  base: {=& baseDir =},
+  envPrefix: "REACT_APP_",
+  "build.outDir": "{= clientBuildDirPath =}",
+  // Heads up! The env referred to by `clientPortEnvVarName` is empty during
+  // `build`, so it's not persisted in the final output.
+  "server.port": envVarAsNumber("{= clientPortEnvVarName =}"),
+  "server.strictPort": true,
+  // `vite preview` falls back to `server` for most options, but not for `port`
+  // (it has its own default), so we have to set it separately.
+  "preview.port": envVarAsNumber("{= clientPortEnvVarName =}"),
 } as const;
 
+const forcedOptionHints: Partial<Record<keyof typeof forcedOptions, string>> = {
+  base: "To serve your app from a subdirectory, set `client.baseDir` in your Wasp config.",
+  "server.port":
+    "To run the client on a different port, use `wasp start --client-port <port>`.",
+  "preview.port":
+    "To run the client on a different port, use `wasp build start --client-port <port>`.",
+};
+
 export function waspConfig(): PluginOption {
   return {
     name: "wasp:config",
-    enforce: 'pre',
+    enforce: "pre",
     config(config) {
       throwIfOverridingForcedOptions(config);
 
       // Returned config is merged with the user's config by Vite (mergeConfig).
       return {
-        base: forcedOptions['base'],
+        base: forcedOptions["base"],
         optimizeDeps: {
           exclude: {=& depsExcludedFromOptimization =}
         },
         server: {
-          port: useUserValue(config.server?.port, {= defaultClientPort =}),
+          port: forcedOptions["server.port"],
+          strictPort: forcedOptions["server.strictPort"],
           host: useUserValue(config.server?.host, "0.0.0.0"),
         },
-        envPrefix: forcedOptions['envPrefix'],
+        preview: {
+          port: forcedOptions["preview.port"],
+        },
+        envPrefix: forcedOptions["envPrefix"],
         build: {
-          outDir: forcedOptions['build.outDir'],
+          outDir: forcedOptions["build.outDir"],
+        },
+        ssr: {
+          noExternal: ["@wasp.sh/lib-sdk-core"],
         },
         resolve: {
           // These packages rely on a single instance per page. Not deduping them
           // causes runtime errors (e.g., hook rule violation in react, QueryClient
           // instance error in react-query, Invariant Error in react-router).
-          dedupe: ["react", "react-dom", "@tanstack/react-query", "react-router"],
+          dedupe: [
+            "react",
+            "react-dom",
+            "@tanstack/react-query",
+            "react-router",
+          ],
           alias: [
             {
               // Vite doesn't look for `.prisma/client` imports in the `node_modules`
@@ -69,10 +97,10 @@ export function waspConfig(): PluginOption {
           exclude: [
             ...defaultExclude,
             "{= vitest.excludeWaspArtefactsPattern =}",
-          ]
+          ],
         },
       };
-    }
+    },
   };
 }
 
@@ -85,18 +113,32 @@ function throwIfOverridingForcedOptions(config: Record<string, any>): void {
   for (const [path, forcedValue] of Object.entries(forcedOptions)) {
     const userValue = getByPath(config, path);
     if (userValue !== undefined && userValue !== forcedValue) {
+      const hint = forcedOptionHints[path as keyof typeof forcedOptions];
       conflicts.push(
-        `  - "${path}" is set to ${JSON.stringify(userValue)}, but Wasp requires ${JSON.stringify(forcedValue)}`
+        `  - "${path}" is set to ${JSON.stringify(userValue)}, but Wasp requires ${JSON.stringify(forcedValue)}` +
+          (hint ? `\n    ${hint}` : ""),
       );
     }
   }
   if (conflicts.length > 0) {
     throw new Error(
-      `Your vite.config.ts sets options that Wasp controls:\n${conflicts.join('\n')}\n\nRemove these from your Vite config, Wasp sets them automatically.`
+      `Your vite.config.ts sets options that Wasp controls:\n${conflicts.join("\n")}\n\nRemove these from your Vite config, Wasp sets them automatically.`,
     );
   }
 }
 
 function getByPath(obj: Record<string, any>, path: string): unknown {
-  return path.split('.').reduce<any>((node, segment) => node?.[segment], obj);
+  return path.split(".").reduce<any>((node, segment) => node?.[segment], obj);
+}
+
+function envVarAsNumber(envName: string): number | undefined {
+  const strValue = process.env[envName];
+  if (strValue === undefined) {
+    return undefined;
+  }
+  const numValue = Number.parseInt(strValue);
+  if (Number.isNaN(numValue)) {
+    throw new Error(`Environment variable ${envName} is not a valid number.`);
+  }
+  return numValue;
 }

package/data/Generator/templates/sdk/wasp/client/vite/virtual-files/files/client-entry.tsx

@@ -10,7 +10,7 @@ import { WaspApp } from "wasp/client/app";
 {=& routeObjects.importStatement =}
 
 const router = createBrowserRouter({= routeObjects.importIdentifier =}, {
-  basename: "{= baseDir =}",
+  basename: {=& baseDir =},
   // React Router will put hydration data on this property of the `window` object.
   // https://reactrouter.com/8.0.1/start/data/custom#4-hydrate-in-the-browser
   hydrationData: window.__staticRouterHydrationData,

package/data/Generator/templates/sdk/wasp/client/vite/virtual-files/files/routes.tsx

@@ -1,6 +1,6 @@
 {{={= =}=}}
 import { getRouteObjects } from "wasp/client/app/router";
-import { initializeQueryClient } from "wasp/client/operations";
+import { initializeQueryClient } from "@wasp.sh/lib-sdk-core/browser";
 {=^ rootComponent.isDefined =}
 import { Outlet } from "react-router"
 {=/ rootComponent.isDefined =}

package/data/Generator/templates/sdk/wasp/client/vite/virtual-files/files/ssr-entry.tsx

@@ -42,7 +42,7 @@ const prerenderApp: PrerenderFn = async (route, { clientEntrySrc }) => {
 export default prerenderApp;
 
 const { query, dataRoutes } = createStaticHandler({= routeObjects.importIdentifier =}, {
-  basename: "{= baseDir =}",
+  basename: {=& baseDir =},
 });
 
 async function makeStaticRouterProvider(route: string) {

package/data/Generator/templates/sdk/wasp/client/webSocket/WebSocketProvider.tsx

@@ -1,9 +1,9 @@
 {{={= =}=}}
-import { createContext, useState, useEffect, Context, ReactNode } from 'react'
-import { io, Socket } from 'socket.io-client'
+import { createContext, useState, useEffect, type Context, type ReactNode } from 'react'
+import { io, type Socket } from 'socket.io-client'
+import { apiEventsEmitter } from '@wasp.sh/lib-sdk-core/browser'
 
 import { getSessionId } from '../../api/index.js'
-import { apiEventsEmitter } from '../../api/events.js'
 import { config } from '../index.js'
 
 import type { ClientToServerEvents, ServerToClientEvents } from '../../server/webSocket/index.js';

package/data/Generator/templates/sdk/wasp/client/webSocket/index.ts

@@ -1,5 +1,5 @@
 import { useContext, useEffect } from 'react'
-import { WebSocketContext, WebSocketContextValue } from './WebSocketProvider'
+import { WebSocketContext, type WebSocketContextValue } from './WebSocketProvider'
 import type {
   ClientToServerEvents,
   ServerToClientEvents,

package/data/Generator/templates/sdk/wasp/core/serialization/index.ts

@@ -1,56 +1,11 @@
 {{={= =}=}}
 import { deserialize, serialize } from "superjson"
-import { CustomSerializableJSONValue } from "./custom-register"
+
 
 {=# entitiesExist =}
 import "./prisma"
 {=/ entitiesExist =}
 
-export type Payload = void | SuperJSONValue;
-
-// The part below was copied from SuperJSON and slightly modified:
-// https://github.com/blitz-js/superjson/blob/ae7dbcefe5d3ece5b04be0c6afe6b40f3a44a22a/src/types.ts
-//
-// We couldn't use SuperJSON's types directly because:
-//   1. They have a weird quirk that turns `SuperJSONValue` into `any`.
-//      See why here:
-//      https://github.com/blitz-js/superjson/pull/36#issuecomment-669239876
-//   2. We need to add our own custom types to the serialization process.
-//
-// We changed the code as little as possible to make future comparisons easier.
-export type JSONValue = PrimitiveJSONValue | JSONArray | JSONObject;
-
-export interface JSONObject {
-  [key: string]: JSONValue;
-}
-
-type PrimitiveJSONValue = string | number | boolean | undefined | null;
-
-export interface JSONArray extends Array<JSONValue> {}
-
-// Removed `Symbol` since we don't explicitly register any symbol to be serialized
-// Added custom types from `CustomSerializableJSONValue`
-export type SerializableJSONValue =
-  | Set<SuperJSONValue>
-  | Map<SuperJSONValue, SuperJSONValue>
-  | undefined
-  | bigint
-  | Date
-  | RegExp
-  | CustomSerializableJSONValue;
-
-// Here's where we excluded `ClassInstance` (which was `any`) from the union.
-export type SuperJSONValue =
-  | JSONValue
-  | SerializableJSONValue
-  | SuperJSONArray
-  | SuperJSONObject;
-
-export interface SuperJSONArray extends Array<SuperJSONValue> {}
-
-export interface SuperJSONObject {
-  [key: string]: SuperJSONValue;
-}
+export { type JSONArray, type JSONObject, type JSONValue, type Payload, type SerializableJSONValue, type SuperJSONArray, type SuperJSONObject, type SuperJSONValue } from '@wasp.sh/lib-sdk-core'
 
 export { deserialize, serialize }
-

package/data/Generator/templates/sdk/wasp/core/serialization/prisma.ts

@@ -1,6 +1,5 @@
 import { Prisma } from "@prisma/client"
 import { registerCustom } from "superjson"
-import "./custom-register"
 
 // This file is only added if there are (Prisma) entities in the AppSpec.
 

package/data/Generator/templates/sdk/wasp/entities/index.ts

@@ -1,17 +1,17 @@
 {{={= =}=}}
-import {
+import type {
   {=# entities =}
-  type {= name =},
+  {= name =},
   {=/ entities =}
 } from "@prisma/client"
 
-export {
+export type {
   {=# entities =}
-  type {= name =},
+  {= name =},
   {=/ entities =}
   {=# isAuthEnabled =}
-  type {= authEntityName =},
-  type {= authIdentityEntityName =},
+  {= authEntityName =},
+  {= authIdentityEntityName =},
   {=/ isAuthEnabled =}
 } from "@prisma/client"
 

package/data/Generator/templates/sdk/wasp/env/index.ts

@@ -1,9 +1 @@
-import * as z from 'zod'
-
-// PUBLIC API
-export function defineEnvValidationSchema<Schema extends z.ZodObject>(
-  schema: Schema,
-): Schema {
-  return schema
-}
-
+export { defineEnvValidationSchema } from '@wasp.sh/lib-sdk-core'