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

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

@@ -5,11 +5,11 @@ export { default as config } from './config.js'
 // PUBLIC API
 export { default as prisma, type PrismaClient } from './dbClient.js'
 // PUBLIC API
-export { type ServerSetupFn } from './types/index.js'
+export type { ServerSetupFn } from './types/index.js'
 // PUBLIC API
-export { HttpError } from './HttpError.js'
+export { HttpError } from '@wasp.sh/lib-sdk-core'
 // PUBLIC API
-export { MiddlewareConfigFn } from './middleware/index.js'
+export type { MiddlewareConfigFn } from './middleware/index.js'
 // PUBLIC API
 export { env } from './env.js'
 

package/data/Generator/templates/sdk/wasp/server/jobs/_job.ts

@@ -14,7 +14,7 @@ export type {= typeName =}<Input extends JSONObject, Output extends JSONValue |
 
 {=# jobSchedule.isDefined =}
 const jobSchedule = {
-  cron: "{= jobSchedule.cron =}",
+  cron: {=& jobSchedule.cron =},
   {=# jobSchedule.args.isDefined =}
   args: {=& jobSchedule.args.json =},
   {=/ jobSchedule.args.isDefined =}

package/data/Generator/templates/sdk/wasp/server/jobs/core/pgBoss/index.ts

@@ -1,3 +1,3 @@
-export { type JobFn } from './types'
+export type { JobFn } from './types'
 export { registerJob, createJobDefinition } from './pgBossJob.js'
 export { startPgBoss } from './pgBoss.js'

package/data/Generator/templates/sdk/wasp/server/jobs/core/pgBoss/pgBossJob.ts

@@ -1,12 +1,12 @@
+import { PG_BOSS_EXECUTOR_NAME } from '@wasp.sh/lib-sdk-core/node'
+export { PG_BOSS_EXECUTOR_NAME } from '@wasp.sh/lib-sdk-core/node'
 import PgBoss from 'pg-boss'
 import { pgBossStarted } from './pgBoss.js'
-import { Job, SubmittedJob } from '../job.js'
+import { Job, SubmittedJob } from '@wasp.sh/lib-sdk-core'
 import type { JSONValue, JSONObject } from '../../../../core/serialization/index.js'
-import { PrismaDelegate } from '../../../_types/index.js'
+import type { PrismaDelegate } from '../../../_types/index.js'
 import type { JobFn } from './types.js'
 
-export const PG_BOSS_EXECUTOR_NAME = Symbol('PgBoss')
-
 type JobSchedule = {
   cron: Parameters<PgBoss['schedule']>[1]
   options: Parameters<PgBoss['schedule']>[3]

package/data/Generator/templates/sdk/wasp/server/jobs/core/pgBoss/types.ts

@@ -1,4 +1,4 @@
-import { PrismaDelegate } from '../../../_types/index.js'
+import type { PrismaDelegate } from '../../../_types/index.js'
 import type { JSONValue, JSONObject } from '../../../../core/serialization/index.js'
 
 // PRIVATE API

package/data/Generator/templates/sdk/wasp/server/middleware/index.ts

@@ -1 +1 @@
-export * from './globalMiddleware.js'
+export { type MiddlewareConfig, type MiddlewareConfigFn } from '@wasp.sh/lib-sdk-core/node'

package/data/Generator/templates/sdk/wasp/server/operations/actions/index.ts

@@ -5,7 +5,7 @@
 {=! TODO: This will generate multiple import statements even though they're
           importing symbols from the same file. We should improve our importing machinery
           to support multiple imports from the same file =}
-import { prisma } from '../../index.js'
+import { prisma } from '../../index'
 import {
   type UnauthenticatedOperationFor,
   createUnauthenticatedOperation,
@@ -13,25 +13,31 @@ import {
   type AuthenticatedOperationFor,
   createAuthenticatedOperation,
   {=/ isAuthEnabled =}
-} from '../wrappers.js'
+} from '../wrappers'
+import type { FromRegisterPath } from '../../../types/register'
+import type {
+  {=# operations =}
+  {= genericOperationDefinitionTypeName =},
+  {=/ operations =}
+} from './types'
 {=# operations =}
 {=& jsFn.importStatement =}
 {=/ operations =}
 {=# operations =}
 
 // PRIVATE API
-export type {= operationTypeName =} = typeof {= jsFn.importIdentifier =}
+export type {= registeredOperationTypeName =} = FromRegisterPath<['operations', '{= operationName =}'], {= genericOperationDefinitionTypeName =}>
 
 // PUBLIC API
 {=# usesAuth =}
-export const {= operationName =}: AuthenticatedOperationFor<{= operationTypeName =}> =
-  createAuthenticatedOperation(
+export const {= operationName =}: AuthenticatedOperationFor<{= registeredOperationTypeName =}> =
+  createAuthenticatedOperation<{= registeredOperationTypeName =}>(
 {=/ usesAuth =}
 {=^ usesAuth =}
-export const {= operationName =}: UnauthenticatedOperationFor<{= operationTypeName =}> =
-  createUnauthenticatedOperation(
+export const {= operationName =}: UnauthenticatedOperationFor<{= registeredOperationTypeName =}> =
+  createUnauthenticatedOperation<{= registeredOperationTypeName =}>(
 {=/ usesAuth =}
-    {= jsFn.importIdentifier =},
+    () => {= jsFn.importIdentifier =},
     {
       {=# entities =}
       {= name =}: prisma.{= prismaIdentifier =},

package/data/Generator/templates/sdk/wasp/server/operations/actions/types.ts

@@ -1,17 +1,17 @@
 {{={= =}=}}
 {=! TODO: This template is exactly the same at the moment as one for query
           types, consider whether it makes sense to address this in the future. =}
-import {
+import type {
   {=# allEntities =}
-  type {= internalTypeName =},
+  {= internalTypeName =},
   {=/ allEntities =}
   {=# shouldImportNonAuthenticatedOperation =}
-  type UnauthenticatedActionDefinition,
+  UnauthenticatedActionDefinition,
   {=/ shouldImportNonAuthenticatedOperation =}
   {=# shouldImportAuthenticatedOperation =}
-  type AuthenticatedActionDefinition,
+  AuthenticatedActionDefinition,
   {=/ shouldImportAuthenticatedOperation =}
-  type Payload,
+  Payload,
 } from '../../_types/index.js'
 
 {=# operations =}

package/data/Generator/templates/sdk/wasp/server/operations/queries/index.ts

@@ -5,7 +5,7 @@
 {=! TODO: This will generate multiple import statements even though they're
           importing symbols from the same file. We should improve our importing machinery
           to support multiple imports from the same file =}
-import { prisma } from '../../index.js'
+import { prisma } from '../../index'
 import {
   type UnauthenticatedOperationFor,
   createUnauthenticatedOperation,
@@ -13,25 +13,31 @@ import {
   type AuthenticatedOperationFor,
   createAuthenticatedOperation,
   {=/ isAuthEnabled =}
-} from '../wrappers.js'
+} from '../wrappers'
+import type { FromRegisterPath } from '../../../types/register'
+import type {
+  {=# operations =}
+  {= genericOperationDefinitionTypeName =},
+  {=/ operations =}
+} from './types'
 {=# operations =}
 {=& jsFn.importStatement =}
 {=/ operations =}
 {=# operations =}
 
 // PRIVATE API
-export type {= operationTypeName =} = typeof {= jsFn.importIdentifier =}
+export type {= registeredOperationTypeName =} = FromRegisterPath<['operations', '{= operationName =}'], {= genericOperationDefinitionTypeName =}>
 
 // PUBLIC API
 {=# usesAuth =}
-export const {= operationName =}: AuthenticatedOperationFor<{= operationTypeName =}> =
-  createAuthenticatedOperation(
+export const {= operationName =}: AuthenticatedOperationFor<{= registeredOperationTypeName =}> =
+  createAuthenticatedOperation<{= registeredOperationTypeName =}>(
 {=/ usesAuth =}
 {=^ usesAuth =}
-export const {= operationName =}: UnauthenticatedOperationFor<{= operationTypeName =}> =
-  createUnauthenticatedOperation(
+export const {= operationName =}: UnauthenticatedOperationFor<{= registeredOperationTypeName =}> =
+  createUnauthenticatedOperation<{= registeredOperationTypeName =}>(
 {=/ usesAuth =}
-    {= jsFn.importIdentifier =},
+    () => {= jsFn.importIdentifier =},
     {
       {=# entities =}
       {= name =}: prisma.{= prismaIdentifier =},

package/data/Generator/templates/sdk/wasp/server/operations/queries/types.ts

@@ -2,17 +2,17 @@
 {=! TODO: This template is exactly the same at the moment as one for action
           types, consider whether it makes sense to address this in the future. =}
 
-import {
+import type {
   {=# allEntities =}
-  type {= internalTypeName =},
+  {= internalTypeName =},
   {=/ allEntities =}
   {=# shouldImportNonAuthenticatedOperation =}
-  type UnauthenticatedQueryDefinition,
+  UnauthenticatedQueryDefinition,
   {=/ shouldImportNonAuthenticatedOperation =}
   {=# shouldImportAuthenticatedOperation =}
-  type AuthenticatedQueryDefinition,
+  AuthenticatedQueryDefinition,
   {=/ shouldImportAuthenticatedOperation =}
-  type Payload,
+  Payload,
 } from '../../_types/index.js'
 
 {=# operations =}

package/data/Generator/templates/sdk/wasp/server/operations/wrappers.ts

@@ -1,10 +1,10 @@
 {{={= =}=}}
-import { IfAny, _Awaited, _ReturnType, _Parameters } from '../../universal/types'
+import type { IfAny, _Awaited, _Parameters, _ReturnType } from '@wasp.sh/lib-sdk-core'
 
 {=# isAuthEnabled =}
-import { type AuthUser } from '../auth/user.js'
+import type { AuthUser } from '../../auth/user.js'
 {=/ isAuthEnabled =}
-import {
+import type {
   _Entity,
   {=# isAuthEnabled =}
   AuthenticatedOperationDefinition,
@@ -39,19 +39,43 @@ export type UnauthenticatedOperationFor<
 /**
  * Creates the server-side API for an unauthenticated operation.
  *
+ * The operation definition is accepted through a getter instead of directly to
+ * prevent "use before initialization" errors. When a user's operation definition
+ * imports another operation's server-side API (i.e., imports from `"wasp/server/operations"`),
+ * that module and ours form a cycle. Depending on which side of the cycle the
+ * bundler enters first, it can emit our {@link createUnauthenticatedOperation}
+ * wrapper calls above the user's operation definitions:
+ * ```ts
+ * function badCreateOperation(fn: Function) {
+ *   return () => fn();
+ * }
+ * const badServerOperation = badCreateOperation(someUserOperation);
+ *       ^! ReferenceError: Cannot access 'someUserOperation' before initialization
+ * const someUserOperation = () => 1;
+ * ```
+ * 
+ * The getter defers the read until the operation is called, by which point every
+ * module is initialized:
+ * ```ts
+ * function goodCreateOperation(fn: () => Function) {
+ *   return () => fn()();
+ * }
+ * const goodServerOperation = goodCreateOperation(() => someUserOperation);
+ * const someUserOperation = () => 1;
+ * ```
  * @template OperationDefinition The type of the unauthenticated operation's definition.
- * @param userOperation The unauthenticated operation's definition.
- * @param entities The unauthenticated operation's entity map .
+ * @param getUserOperation Returns the unauthenticated operation's definition.
+ * @param entities The unauthenticated operation's entity map.
  * @returns The server-side API for the provided unauthenticated operation.
  */
 export function createUnauthenticatedOperation<
   OperationDefinition extends GenericUnauthenticatedOperationDefinition
 >(
-  userOperation: OperationDefinition,
+  getUserOperation: () => OperationDefinition,
   entities: EntityMapFor<OperationDefinition>
 ): UnauthenticatedOperationFor<OperationDefinition> {
   async function operation(payload: Parameters<OperationDefinition>[0]) {
-    return userOperation(payload, {
+    return getUserOperation()(payload, {
       entities,
     })
   }
@@ -93,16 +117,18 @@ export type AuthenticatedOperationContext = { user: AuthUser }
 // PRIVATE API (used in SDK)
 /**
  * Creates the server-side API for an authenticated operation.
- *
+ * For an explanation of why we accept an operation definition getter instead
+ * of the value directly, check {@link createUnauthenticatedOperation}.
+ * 
  * @template OperationDefinition The type of the authenticated operation's definition.
- * @param userOperation The authenticated operation's definition.
- * @param entities The authenticated operation's entity map .
+ * @param getUserOperation Returns the authenticated operation's definition.
+ * @param entities The authenticated operation's entity map.
  * @returns The server-side API for the provided authenticated operation.
  */
 export function createAuthenticatedOperation<
   OperationDefinition extends GenericAuthenticatedOperationDefinition
 >(
-  userOperation: OperationDefinition,
+  getUserOperation: () => OperationDefinition,
   entities: EntityMapFor<OperationDefinition>
 ): AuthenticatedOperationFor<OperationDefinition> {
   async function operation(...args: AuthenticatedOperationArgsFor<OperationDefinition>) {
@@ -113,20 +139,20 @@ export function createAuthenticatedOperation<
       throw new Error(`
         You called the operation without arguments, which is a mistake.
         Check your definition and read the docs to understand what you need to send:
-        https://wasp.sh/docs/data-model/operations/overview
+        https://wasp.sh/docs/features/data/operations/overview
         `
       )
     } else if (includesPayload(args)) {
       // Two arguments sent -> the first argument is the payload, the second is the context.
       const [payload, context] = args
-      return userOperation(payload as Parameters<OperationDefinition>[0], {
+      return getUserOperation()(payload as Parameters<OperationDefinition>[0], {
         ...context,
         entities,
       })
     } else {
       // One argument sent -> the first and only argument is the user.
       const [context] = args
-      return userOperation(undefined as Parameters<OperationDefinition>[0], {
+      return getUserOperation()(undefined as Parameters<OperationDefinition>[0], {
         ...context,
         entities,
       })

package/data/Generator/templates/sdk/wasp/server/types/index.ts

@@ -1,11 +1 @@
-import { type Application } from 'express'
-import { Server } from 'http'
-
-// PUBLIC API
-export type ServerSetupFn = (context: ServerSetupFnContext) => Promise<void>
-
-// PRIVATE API (server)
-export type ServerSetupFnContext = {
-  app: Application,
-  server: Server,
-}
+export { type ServerSetupFn, type ServerSetupFnContext } from '@wasp.sh/lib-sdk-core/node'

package/data/Generator/templates/sdk/wasp/server/utils.ts

@@ -1,8 +1,11 @@
 {{={= =}=}}
-import { Response, RequestHandler } from 'express'
+
+export { defineHandler, redirect } from '@wasp.sh/lib-sdk-core/node'
+
+export { sleep } from '@wasp.sh/lib-sdk-core'
 
 {=# isAuthEnabled =}
-import { type AuthUserData } from './auth/user.js'
+import type { AuthUserData } from '../auth/user.js'
 {=/ isAuthEnabled =}
 
 // This is explicitly how Express expects extensions to their
@@ -18,21 +21,3 @@ declare global {
     }
   }
 }
-
-/**
- * Simple helper to give the correct types for Express handlers.
- * We define it in the same file as our extension to Request
- * so that it is picked up by TypeScript.
- */
-export const defineHandler = <T extends RequestHandler>(
-  middleware: T
-): T => middleware
-
-export const sleep = (ms: number): Promise<unknown> => new Promise((r) => setTimeout(r, ms))
-
-export function redirect(res: Response, redirectUri: string)  {
-  return res
-    .status(302)
-    .setHeader("Location", redirectUri)
-    .end();
-}

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

@@ -1,14 +1,14 @@
 {{={= =}=}}
 
-import { Server } from 'socket.io'
-import { EventsMap, DefaultEventsMap } from '@socket.io/component-emitter'
+import type { Server } from 'socket.io'
+import type { EventsMap, DefaultEventsMap } from '@socket.io/component-emitter'
 
-import { prisma } from '../index.js'
+import type { prisma } from '../index'
+import type { FromRegister } from '../../types/register'
 {=# isAuthEnabled =}
-import { type AuthUser } from '../auth/user.js'
+import type { AuthUser } from '../../auth/user.js'
 {=/ isAuthEnabled =}
 
-{=& userWebSocketFn.importStatement =}
 
 // Public API
 export type WebSocketDefinition<
@@ -40,14 +40,14 @@ export interface WaspSocketData {
 }
 
 // PRIVATE API (framework)
-export type ServerType = Parameters<WebSocketFn>[0]
+export type ServerType = Parameters<RegisteredWebSocketFn>[0]
 
 // PRIVATE API (sdk)
 export type ClientToServerEvents = Events[0]
 // PRIVATE API (sdk)
 export type ServerToClientEvents = Events[1]
 
-type WebSocketFn = typeof {= userWebSocketFn.importIdentifier =}
+type RegisteredWebSocketFn = FromRegister<'webSocketFn', WebSocketDefinition>;
 type Events = ServerType extends Server<
   infer ClientToServerEvents,
   infer ServerToClientEvents

package/data/Generator/templates/sdk/wasp/tsconfig.json

@@ -15,25 +15,14 @@
     "outDir": "dist",
 
     /* Strictness and type checking */
-    /*
-       User code was compiled using `"strict": true`, so we know we can use it
-       here as well. We override some of strict's options because parts of the SDK
-       code don't respect them. This only makes the SDK ruleset more permissive than
-       the user's ruleset. Therefore, we can sefely include users code inside the
-       SDK without casuing errors during the SDK build step.
-       Reference: https://github.com/wasp-lang/wasp/issues/1938
-    */
     "strict": true,
-    "useUnknownInCatchVariables": false,
-    "noImplicitAny": false,
-    "strictPropertyInitialization": false,
-    /*
-       The following two properties are disabled because we don't
-       yet want to force user code to use them.
-       Reference: https://github.com/wasp-lang/wasp/issues/2655
-    */
-    "noUncheckedIndexedAccess": false,
-    "noImplicitOverride": false,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "noUnusedParameters": true,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
 
     /* DX */
     "declaration": true, // Allows users to consume the SDK as a library, enables autocomplete
@@ -43,37 +32,22 @@
     /* Modules */
     "module": "esnext",
     "esModuleInterop": true,
-    // TODO: Enable this once we enable it for users:
-    // https://github.com/wasp-lang/wasp/issues/2654
-    "resolveJsonModule": false,
-    /*
-       The `isolatedModules` flag tells typescript to throw errors on code that
-       doesn't work with bundlers:
-         - The user code must enable it because Wasp bundles user code when bundling
-        server code and web app code (which directly import the user code).
-         - The SDK code must disable it because parts of the SDK code rely on
-        such features. Since we build the SDK with TSC before bundling it,
-        these features don't cause problems.
-      More details in https://github.com/wasp-lang/wasp/issues/2150
-    */
-    "isolatedModules": false,
-    // `verbatimModuleSyntax` is disabled because we don't yet want to
-    // force user code into using `type` imports.
-    "verbatimModuleSyntax": false,
+    "resolveJsonModule": true,
+    // `isolatedModules` rejects code that single-file transpilers (like esbuild)
+    // can't handle. The SDK gets bundled, so it must not rely on such code.
+    "isolatedModules": true,
+    // `verbatimModuleSyntax` makes type-only imports explicit, so single-file
+    // transpilers can drop them without having to know what they refer to.
+    "verbatimModuleSyntax": true,
     "moduleDetection": "force", // Assume all files are modules
     /*
-      - We want to allow users to use extensionless and directory imports.
-      - We want users to import stuff from the SDK with `wasp/something`, and we
-        don't want to do extra processing on those imports (for now).
-
-      These requirements force us to bundle user code and, because we copy user
-      code into the SDK code, they force us to bundle the SDK too.
+      The SDK code uses extensionless relative imports and imports its own
+      modules through the `wasp/*` package exports. TSC emits those imports
+      as-is, and only a bundler can resolve them at runtime.
 
-      We currently bundle the SDK in a very hacky way (indirectly while bundling
-      the server and client): https://github.com/wasp-lang/wasp/issues/2150
-      Regardless of how we do it, the SDK code is eventually bundled, so this
-      `tsconfig.json` file must reflect that (which means `moduleResolution:
-      bundler`).
+      The SDK output is never run directly: it's bundled into the server and
+      the client (https://github.com/wasp-lang/wasp/issues/2150), so this
+      `tsconfig.json` must resolve modules the way a bundler does.
     */
     "moduleResolution": "bundler",
     /*

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

@@ -0,0 +1,8 @@
+/**
+ * Register for type augmentation via declaration merging.
+ *
+ * Declared here to work around stale TypeScript incremental diagnostics
+ * when augmenting a re-exported interface.
+ * See https://github.com/wasp-lang/wasp/pull/4885.
+ */
+export interface Register {}

package/data/Generator/templates/sdk/wasp/types/register.ts

@@ -0,0 +1,21 @@
+import type { Register } from "./index";
+
+/**
+ * Safely reads a value from {@link Register} by following {@link Path}.
+ * Returns the registered type, or {@link Fallback} if any step of the path is missing.
+ * The path can be of any depth.
+ */
+export type FromRegisterPath<Path extends readonly string[], Fallback> =
+  WalkRegisterPath<Register, Path, Fallback>;
+
+type WalkRegisterPath<Current, Path extends readonly string[], Fallback> =
+  Path extends readonly [infer Key extends string, ...infer Rest extends readonly string[]]
+    ? Key extends keyof Current
+      ? WalkRegisterPath<Current[Key], Rest, Fallback>
+      : Fallback
+    : Current;
+
+/**
+ * Shorthand for reading a top-level {@link Register} value.
+ */
+export type FromRegister<Key extends string, Fallback> = FromRegisterPath<[Key], Fallback>;

package/data/Generator/templates/sdk/wasp/vite-env.d.ts

@@ -1,10 +1 @@
 /// <reference types="vite/client" />
-
-interface WaspSSRData {
-  isFallbackPage: boolean
-}
-
-interface Window {
-  __WASP_SSR_DATA__?: WaspSSRData
-  __staticRouterHydrationData?: import("react-router").HydrationState
-}

package/data/Generator/templates/sdk/wasp/wasp-ssr.d.ts

@@ -0,0 +1,8 @@
+interface WaspSSRData {
+  isFallbackPage: boolean
+}
+
+interface Window {
+  __WASP_SSR_DATA__?: WaspSSRData
+  __staticRouterHydrationData?: import("react-router").HydrationState
+}

package/data/Generator/templates/sdk/wasp/wasp-user-virtual-modules.d.ts

@@ -0,0 +1,20 @@
+{{={= =}=}}
+/**
+ * Declares the virtual user modules the SDK imports.
+ * 
+ * The types are written as inline `import("...")` types on purpose.
+ * Ambient module declarations can't reach another module through a
+ * relative import statement (TS2439).
+ */
+{=# virtualUserModules =}
+
+declare module {=& virtualModuleId =} {
+  {=# isDefaultExport =}
+  const _default: {=& declaredType =};
+  export default _default;
+  {=/ isDefaultExport =}
+  {=^ isDefaultExport =}
+  export const {=& exportName =}: {=& declaredType =};
+  {=/ isDefaultExport =}
+}
+{=/ virtualUserModules =}

package/data/Generator/templates/server/package.json

@@ -10,7 +10,8 @@
     "start": "node --enable-source-maps -r dotenv/config bundle/server.js",
     "bundle-and-start": "npm run bundle && npm run start",
     "watch": "nodemon --exec 'npm run bundle-and-start || exit 1'",
-    "db-seed": "npm run bundle && node --enable-source-maps -r dotenv/config bundle/dbSeed.js",
+    "bundle-db-seed": "tsc --build && rollup --config rollup.dbSeed.config.js --silent",
+    "db-seed": "npm run bundle-db-seed && node --enable-source-maps -r dotenv/config bundle/dbSeed.js",
     "db-migrate-prod": "prisma migrate deploy --schema=../db/schema.prisma",
     "start-production": "{=& startProductionScript =}"
   },

package/data/Generator/templates/server/rollup.config.js

@@ -1,44 +1,3 @@
-{{={= =}=}}
-import esbuild from 'rollup-plugin-esbuild'
-import resolve from '@rollup/plugin-node-resolve';
+import { createRollupBundle } from "./src/createRollupBundle.js";
 
-export default [
-  createBundle('src/server.ts', 'bundle/server.js'),
-  {=# areDbSeedsDefined =}
-  createBundle('src/dbSeed.ts', 'bundle/dbSeed.js'),
-  {=/ areDbSeedsDefined =}
-]
-
-function createBundle(inputFilePath, outputFilePath) {
-  return {
-    input: inputFilePath,
-    output: {
-      file: outputFilePath,
-      format: 'es',
-      sourcemap: true,
-    },
-    plugins: [
-      resolve(),
-      esbuild({
-        target: 'esnext',
-      }),
-    ],
-    // We don't want to bundle any of the node_module deps because we want to
-    // keep them as external dependencies.
-    external: /node_modules/,
-    // 'preserveSymlinks: false' tells Rollup to fully follow symlinks when
-    // resolving modules. This is the default option, but we're setting it
-    // explicitly because we rely on it.
-    //
-    // With this set to 'false', the 'wasp' package resolves to
-    // '.wasp/out/sdk/wasp' (not 'node_modules/wasp'), preventing Rollup from
-    // viewing it as an external dependency and ensuring it gets bundled.
-    //
-    // We need to bundle 'wasp' to support fully extensionless relative
-    // imports. See https://github.com/wasp-lang/wasp/issues/2492 for more
-    // details.
-    //
-    // Source: https://rollupjs.org/configuration-options/#preservesymlinks
-    preserveSymlinks: false,
-  }
-}
+export default createRollupBundle("src/server.ts", "bundle/server.js");

package/data/Generator/templates/server/rollup.dbSeed.config.js

@@ -0,0 +1,3 @@
+import { createRollupBundle } from "./src/createRollupBundle.js";
+
+export default createRollupBundle("src/dbSeed.ts", "bundle/dbSeed.js");

package/data/Generator/templates/server/src/app.js

@@ -13,7 +13,7 @@ const app = express()
 app.use('/', indexRouter)
 
 // Custom error handler.
-app.use((err, _req, res, next) => {
+app.use(/** @type {import('express').ErrorRequestHandler} */ ((err, _req, res, next) => {
   // As by expressjs documentation, when the headers have already
   // been sent to the client, we must delegate to the default error handler.
   if (res.headersSent) { return next(err) }
@@ -31,6 +31,6 @@ app.use((err, _req, res, next) => {
   // In development it will also share the error stack though, which is useful.
   // If the user wants to put more information about the error into the response, they should use HttpError.
   return next(err)
-})
+}))
 
 export default app