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

package/data/Generator/templates/server/src/plugins/virtualUserModules.js

@@ -0,0 +1,40 @@
+{{={= =}=}}
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const serverRootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+/**
+ * Maps virtual module IDs (pointing to user's server modules)
+ * to their relative import paths from the server project root.
+ * 
+ * @example 
+ * serverVirtualUserModuleMap["virtual:wasp/user/env"] // => "../../../src/env"
+ *
+ * @type {{ [virtualUserModule: string]: string }}
+ */
+const serverVirtualUserModuleMap = {
+  {=# 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.
+ *
+ * @returns {import("rollup").Plugin}
+ */
+export function virtualUserModules() {
+  return {
+    name: "wasp:virtual-user-modules",
+    async resolveId(id) {
+      if (Object.hasOwn(serverVirtualUserModuleMap, id)) {
+        const absPath = path.resolve(serverRootDir, serverVirtualUserModuleMap[id]);
+        return await this.resolve(absPath, undefined, { skipSelf: true });
+      }
+      return null;
+    },
+  };
+}

package/data/Generator/templates/server/src/routes/apis/index.ts

@@ -4,7 +4,7 @@ import { prisma } from 'wasp/server'
 import { defineHandler } from 'wasp/server/utils'
 import { MiddlewareConfigFn, globalMiddlewareConfigForExpress } from '../../middleware/index.js'
 {=# isAuthEnabled =}
-import auth from 'wasp/core/auth'
+import auth from 'wasp/server/core/auth'
 import { type AuthUserData, makeAuthUserIfPossible } from 'wasp/auth/user'
 {=/ isAuthEnabled =}
 
@@ -30,13 +30,13 @@ const {=& routeMiddlewareConfigFn.importAlias =} = idFn
 const router = express.Router()
 
 {=# apiNamespaces =}
-router.use('{= namespacePath =}', globalMiddlewareConfigForExpress({= namespaceMiddlewareConfigFnImportAlias =}))
+router.use({=& namespacePath =}, globalMiddlewareConfigForExpress({= namespaceMiddlewareConfigFnImportAlias =}))
 {=/ apiNamespaces =}
 
 {=# apiRoutes =}
 const {= apiName =}Middleware = globalMiddlewareConfigForExpress({= routeMiddlewareConfigFn.importAlias =})
 router.{= routeMethod =}(
-  '{= routePath =}',
+  {=& routePath =},
   {=# usesAuth =}
   [auth, ...{= apiName =}Middleware],
   {=/ usesAuth =}

package/data/Generator/templates/server/src/routes/auth/index.js

@@ -1,7 +1,7 @@
 {{={= =}=}}
 import express from 'express'
 
-import auth from 'wasp/core/auth'
+import auth from 'wasp/server/core/auth'
 import me from './me.js'
 import logout from './logout.js'
 

package/data/Generator/templates/server/src/routes/auth/logout.ts

@@ -1,6 +1,6 @@
 import { defineHandler } from 'wasp/server/utils'
-import { createInvalidCredentialsError } from 'wasp/auth/utils'
-import { invalidateSession } from 'wasp/auth/session'
+import { createInvalidCredentialsError } from 'wasp/server/auth/utils'
+import { invalidateSession } from 'wasp/server/auth/session'
 
 export default defineHandler(async (req, res) => {
   if (req.sessionId) {

package/data/Generator/templates/server/src/routes/crud/_crud.ts

@@ -3,7 +3,7 @@ import express from 'express'
 import * as crud from '../../crud/{= crud.name =}.js'
 import { createAction, createQuery } from '../../middleware/operations.js'
 {=# isAuthEnabled =}
-import auth from 'wasp/core/auth'
+import auth from 'wasp/server/core/auth'
 {=/ isAuthEnabled =}
 
 const _waspRouter = express.Router()

package/data/Generator/templates/server/src/routes/index.js

@@ -20,24 +20,6 @@ import { makeWrongPortPage } from '../views/wrong-port.js'
 const router = express.Router()
 const middleware = globalMiddlewareConfigForExpress()
 
-router.get('/', middleware,
-  {=# isDevelopment =}
-    function (_req, res) {
-      const data = {
-        appName: "{= appName =}",
-        frontendUrl: config.frontendUrl
-      };
-      const wrongPortPage = makeWrongPortPage(data);
-      res.status(200).type('html').send(wrongPortPage);
-    }
-  {=/ isDevelopment =}
-  {=^ isDevelopment =}
-    function (_req, res) {
-      res.status(200).send();
-    }
-  {=/ isDevelopment =}
-)
-
 {=# isAuthEnabled =}
 router.use('/auth', middleware, auth)
 {=/ isAuthEnabled =}
@@ -45,6 +27,10 @@ router.use('/{= operationsRouteInRootRouter =}', middleware, operations)
 {=# areThereAnyCrudRoutes =}
 router.use('/{= crudRouteInRootRouter =}', middleware, rootCrudRouter)
 {=/ areThereAnyCrudRoutes =}
+router.get('/{= upRouteInRootRouter =}', middleware, function (_req, res) {
+  res.status(200).json({ status: 'ok' })
+})
+
 {=# areThereAnyCustomApiRoutes =}
 // NOTE: Keep user-defined api routes last so they cannot override our routes.
 // Additionally, do not add middleware to these routes here. Instead, we add
@@ -52,4 +38,18 @@ router.use('/{= crudRouteInRootRouter =}', middleware, rootCrudRouter)
 router.use(apis)
 {=/ areThereAnyCustomApiRoutes =}
 
+{=# isDevelopment =}
+// A page for people who open the server's URL in the browser by mistake.
+// Registered last, so an `api` at `/` answers instead of it, and without the
+// global middleware, since it's only ever read by a human in a browser.
+router.get('/', function (_req, res) {
+  const data = {
+    appName: "{= appName =}",
+    frontendUrl: config.frontendUrl
+  };
+  const wrongPortPage = makeWrongPortPage(data);
+  res.status(200).type('html').send(wrongPortPage);
+})
+{=/ isDevelopment =}
+
 export default router

package/data/Generator/templates/server/src/routes/operations/index.js

@@ -2,7 +2,7 @@
 import express from 'express'
 
 {=# isAuthEnabled =}
-import auth from 'wasp/core/auth'
+import auth from 'wasp/server/core/auth'
 {=/ isAuthEnabled =}
 
 {=# operationRoutes =}

package/data/Generator/templates/server/src/webSocket/initialization.ts

@@ -7,7 +7,7 @@ import type { ServerType } from 'wasp/server/webSocket'
 import { config, prisma } from 'wasp/server'
 
 {=# isAuthEnabled =}
-import { getSessionAndUserFromSessionId } from 'wasp/auth/session'
+import { getSessionAndUserFromSessionId } from 'wasp/server/auth/session'
 import { makeAuthUserIfPossible } from 'wasp/auth/user'
 {=/ isAuthEnabled =}
 

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

@@ -4,19 +4,11 @@
   "compilerOptions": {
     // Overriding this until we implement more complete TypeScript support.
     "strict": false,
+    "useUnknownInCatchVariables": true,
     "allowJs": true,
-
-    // This property currently doesn't matter because we haven't been running
-    // TSC on server code since https://github.com/wasp-lang/wasp/pull/1714.
-    //
-    // When we start running TSC again (after we fix all current errors and
-    // make project references work for the TS config), then I believe the
-    // correct configuration is "rootDir": "." (the project reference should
-    // take care of the user code), but we should double-check.
-    //
-    // Before changing this property, ensure you're aware of the implications:
-    //  - https://github.com/wasp-lang/wasp/pull/1584#discussion_r1404019301
-    //  - https://github.com/wasp-lang/wasp/pull/1713/files#diff-58191eecd9cc55f71c73de89420df8b1866dce38ad35f4ef0f6f8874616eda77R32
+    "checkJs": true,
+    // The project reference takes care of the user project,
+    // so `rootDir` only needs to include the server files.
     "rootDir": ".",
     // Enable source map for debugging
     "sourceMap": true,
@@ -34,7 +26,9 @@
     "types": ["node"]
   },
   "include": [
-    "src"
+    "src",
+    "rollup.config.js",
+    "rollup.dbSeed.config.js"
   ],
   "references": [
     { "path": "{= srcTsConfigPath =}" }

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

@@ -0,0 +1,57 @@
+{{={= =}=}}
+/**
+ * This module augments SDK's `Register` type with the user project types.
+ */
+
+// The import ensures the module is always loaded into the bundle.
+// Otherwise, module augmentation can fail if it wasn't loaded.
+import "wasp/types"
+
+declare module "wasp/types" {
+  interface Register {
+    {=# prismaSetupFn.isDefined =}
+    prismaSetupFn: typeof {=& prismaSetupFn.dynamicImportExpression =}
+    {=/ prismaSetupFn.isDefined =}
+    {=# serverEnvValidationSchema.isDefined =}
+    serverEnvValidationSchema: typeof {=& serverEnvValidationSchema.dynamicImportExpression =}
+    {=/ serverEnvValidationSchema.isDefined =}
+    {=# clientEnvValidationSchema.isDefined =}
+    clientEnvValidationSchema: typeof {=& clientEnvValidationSchema.dynamicImportExpression =}
+    {=/ clientEnvValidationSchema.isDefined =}
+    {=# webSocketFn.isDefined =}
+    webSocketFn: typeof {=& webSocketFn.dynamicImportExpression =}
+    {=/ webSocketFn.isDefined =}
+    {=# emailUserSignupFields.isDefined =}
+    emailUserSignupFields: typeof {=& emailUserSignupFields.dynamicImportExpression =}
+    {=/ emailUserSignupFields.isDefined =}
+    {=# usernameAndPasswordUserSignupFields.isDefined =}
+    usernameAndPasswordUserSignupFields: typeof {=& usernameAndPasswordUserSignupFields.dynamicImportExpression =}
+    {=/ usernameAndPasswordUserSignupFields.isDefined =}
+    operations: {
+    {=# operations =}
+      '{= operationName =}': typeof {=& jsFn.dynamicImportExpression =}
+    {=/ operations =}
+    }
+    crudOverrides: {
+    {=# cruds =}
+      '{= name =}': {
+        {=# overrides.GetAll.isDefined =}
+        GetAll: typeof {=& overrides.GetAll.dynamicImportExpression =}
+        {=/ overrides.GetAll.isDefined =}
+        {=# overrides.Get.isDefined =}
+        Get: typeof {=& overrides.Get.dynamicImportExpression =}
+        {=/ overrides.Get.isDefined =}
+        {=# overrides.Create.isDefined =}
+        Create: typeof {=& overrides.Create.dynamicImportExpression =}
+        {=/ overrides.Create.isDefined =}
+        {=# overrides.Update.isDefined =}
+        Update: typeof {=& overrides.Update.dynamicImportExpression =}
+        {=/ overrides.Update.isDefined =}
+        {=# overrides.Delete.isDefined =}
+        Delete: typeof {=& overrides.Delete.dynamicImportExpression =}
+        {=/ overrides.Delete.isDefined =}
+      }
+    {=/ cruds =}
+    }
+  }
+}

package/data/packages/deploy/dist/common/cliVersion.js

@@ -0,0 +1,17 @@
+import semver from "semver";
+export function parseCliVersion(cliName, rawVersion) {
+    const version = semver.parse(rawVersion);
+    if (version === null) {
+        throw new Error(`Unable to parse ${cliName} version "${rawVersion}".`);
+    }
+    return version;
+}
+export function assertCliVersionMeetsMinimum({ cliName, currentVersion, minimumVersion, updateInstructions, }) {
+    if (!semver.gte(currentVersion, minimumVersion)) {
+        throw new Error([
+            `Wasp expects at least ${cliName} version ${minimumVersion}.`,
+            updateInstructions,
+        ].join("\n"));
+    }
+}
+//# sourceMappingURL=cliVersion.js.map

package/data/packages/deploy/dist/common/waspProject.js

@@ -4,7 +4,7 @@ import { assertDirExists, assertDirPathIsAbsolute } from "./validation.js";
 import { createCommandWithCwd } from "./zx.js";
 export async function assertValidWaspProject(waspProjectDir, waspExe) {
     const waspCli = createCommandWithCwd(waspExe, waspProjectDir);
-    const result = await waspCli(["info"], {
+    const result = await waspCli(["show", "spec", "--json"], {
         quiet: true,
         nothrow: true,
     });

package/data/packages/deploy/dist/common/zx.js

@@ -1,10 +1,28 @@
-import { $ } from "zx";
-export function createCommandWithCwd(command, cwd) {
+import { $, } from "zx";
+export function createCommand(command, defaultOptions = {}) {
     return (commandArgs, options) => {
-        return $({
-            cwd,
-            ...(options ?? {}),
-        }) `${command} ${commandArgs}`;
+        return $({ ...defaultOptions, ...options }) `${command} ${commandArgs}`;
     };
 }
+export function createCommandWithCwd(command, cwd) {
+    return createCommand(command, { cwd });
+}
+export async function runJsonCommand(command, commandArgs, schema) {
+    const result = await command(commandArgs, { verbose: false });
+    return schema.parse(parseJsonFromStdout(result));
+}
+export async function tryRunJsonCommand(command, commandArgs, schema) {
+    const result = await command(commandArgs, { verbose: false, nothrow: true });
+    if (result.exitCode !== 0) {
+        return null;
+    }
+    return schema.parse(parseJsonFromStdout(result));
+}
+// zx's `ProcessOutput.json()` parses the combined stdout and stderr, but CLIs
+// write progress messages to stderr (e.g. `railway add --json` echoes the
+// prompt answers there), which would corrupt the JSON.
+// Reported to zx: https://github.com/google/zx/issues/1505
+function parseJsonFromStdout(output) {
+    return JSON.parse(output.stdout);
+}
 //# sourceMappingURL=zx.js.map

package/data/packages/deploy/dist/providers/fly/commands/createDb/createDb.js

@@ -25,14 +25,22 @@ export async function createDb(region, cmdOptions) {
         "--region",
         deploymentInstructions.region,
         "--vm-size",
-        cmdOptions.vmSize,
+        cmdOptions.dbVmSize,
         "--initial-cluster-size",
-        cmdOptions.initialClusterSize,
+        cmdOptions.dbInitialClusterSize,
         "--volume-size",
-        cmdOptions.volumeSize,
+        cmdOptions.dbVolumeSize,
+        "--image-ref",
+        cmdOptions.dbImage,
     ];
-    if (cmdOptions.dbImage) {
-        createArgs.push("--image-ref", cmdOptions.dbImage);
+    if (cmdOptions.dbVmMemory) {
+        createArgs.push("--vm-memory", cmdOptions.dbVmMemory);
+    }
+    if (cmdOptions.dbVmCpus) {
+        createArgs.push("--vm-cpus", cmdOptions.dbVmCpus);
+    }
+    if (cmdOptions.dbVmCpuKind) {
+        createArgs.push("--vm-cpu-kind", cmdOptions.dbVmCpuKind);
     }
     if (deploymentInstructions.cmdOptions.org) {
         createArgs.push("--org", deploymentInstructions.cmdOptions.org);

package/data/packages/deploy/dist/providers/fly/flyCli.js

@@ -1,17 +1,12 @@
 import { confirm } from "@inquirer/prompts";
+import { SemVer } from "semver";
 import { $ } from "zx";
+import { assertCliVersionMeetsMinimum, parseCliVersion, } from "../../common/cliVersion.js";
 import { getFullCommandName } from "../../common/commander.js";
+import { createCommand, runJsonCommand } from "../../common/zx.js";
 import { executeFlyCommand } from "./index.js";
 import { FlyRegionListSchema, FlySecretListSchema, } from "./jsonOutputSchemas.js";
-export async function flyctlExists() {
-    try {
-        await $ `flyctl version`;
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+const minSupportedFlyCliVersion = new SemVer("0.4.82");
 export async function isUserLoggedIn() {
     try {
         await $ `flyctl auth whoami`;
@@ -40,12 +35,29 @@ async function ensureUserLoggedIn() {
     }
 }
 export async function ensureFlyReady() {
-    const doesFlyctlExist = await flyctlExists();
-    if (!doesFlyctlExist) {
-        throw new Error(`The Fly.io CLI is not available on this system.\nPlease install the flyctl here: https://fly.io/docs/hands-on/install-flyctl`);
-    }
+    const flyCliVersion = await getFlyCliVersion();
+    assertCliVersionMeetsMinimum({
+        cliName: "Fly CLI",
+        currentVersion: flyCliVersion,
+        minimumVersion: minSupportedFlyCliVersion,
+        updateInstructions: "Read how to update the Fly CLI here: https://fly.io/docs/hands-on/install-flyctl",
+    });
     await ensureUserLoggedIn();
 }
+async function getFlyCliVersion() {
+    const result = await $({ nothrow: true }) `flyctl version`;
+    if (result.exitCode !== 0) {
+        throw new Error([
+            "Failed to get Fly CLI version. Most likely the Fly CLI is not installed.",
+            "Read how to install the Fly CLI here: https://fly.io/docs/hands-on/install-flyctl",
+        ].join("\n"));
+    }
+    const match = result.stdout.match(/flyctl(?:\.exe)? v?(\S+)/);
+    if (match === null) {
+        throw new Error(`Failed to get Fly CLI version from output "${result.stdout.trim()}".`);
+    }
+    return parseCliVersion("Fly CLI", match[1]);
+}
 export async function assertRegionIsValid(region) {
     const validRegion = await regionExists(region);
     if (!validRegion) {
@@ -57,15 +69,15 @@ export async function assertRegionIsValid(region) {
     }
 }
 async function regionExists(regionCode) {
-    const proc = await $ `flyctl platform regions -j`.verbose(false);
-    const regions = FlyRegionListSchema.parse(proc.json());
+    const flyCli = createCommand("flyctl");
+    const regions = await runJsonCommand(flyCli, ["platform", "regions", "-j"], FlyRegionListSchema);
     return regions.some((r) => {
         return r.code === regionCode;
     });
 }
 export async function secretExists(secretName) {
-    const proc = await $ `flyctl secrets list -j`;
-    const secrets = FlySecretListSchema.parse(proc.json());
+    const flyCli = createCommand("flyctl");
+    const secrets = await runJsonCommand(flyCli, ["secrets", "list", "-j"], FlySecretListSchema);
     return secrets.some((s) => s.name === secretName);
 }
 //# sourceMappingURL=flyCli.js.map

package/data/packages/deploy/dist/providers/fly/index.js

@@ -8,18 +8,26 @@ import { setup as setupFn } from "./commands/setup/setup.js";
 import { ContextOption } from "./CommonOps.js";
 import { assertRegionIsValid, ensureFlyReady } from "./flyCli.js";
 import { assertFlyTomlDirIsAbsoluteAndPresent } from "./tomlFile.js";
+// Pinned to the same Postgres major as Wasp's dev database (keep in sync with
+// Wasp.Db.Postgres.defaultPostgresDockerImageSpec). Without an explicit image,
+// flyctl uses a server-side default that Fly can bump across majors
+// (wasp-lang/wasp#4564).
+const defaultDbImage = "flyio/postgres-flex:18";
 class FlyCommand extends Command {
     addBasenameArgument() {
         return this.argument("<basename>", "base app name to use on Fly.io (must be unique)");
     }
     addRegionArgument() {
-        return this.argument("<region>", "3 letter deployment region to use on Fly.io");
+        return this.argument("<region>", "3 letter deployment region to use on Fly.io", (region) => region.toLowerCase());
     }
     addDbOptions() {
-        return this.option("--vm-size <vmSize>", "flyctl postgres create option", "shared-cpu-1x")
-            .option("--initial-cluster-size <initialClusterSize>", "flyctl postgres create option", "1")
-            .option("--volume-size <volumeSize>", "flyctl postgres create option", "1")
-            .option("--db-image <dbImage>", "custom Docker image for the PostgreSQL database");
+        return this.option("--db-vm-size <vmSize>", "Fly Postgres VM size", "shared-cpu-1x")
+            .option("--db-vm-memory <vmMemory>", "Fly Postgres VM memory in MB")
+            .option("--db-vm-cpus <vmCpus>", "Fly Postgres VM CPU count")
+            .option("--db-vm-cpu-kind <vmCpuKind>", "Fly Postgres VM CPU kind")
+            .option("--db-initial-cluster-size <initialClusterSize>", "Fly Postgres initial cluster size", "1")
+            .option("--db-volume-size <volumeSize>", "Fly Postgres volume size in GB", "1")
+            .option("--db-image <dbImage>", "Fly Postgres Docker image", defaultDbImage);
     }
     addLocalBuildOption() {
         return this.option("--build-locally", "build Docker containers locally instead of remotely", false);
@@ -73,9 +81,9 @@ export function createFlyCommand() {
         });
     });
     // Add command-specific hooks.
-    flyLaunchCommand.hook("preAction", (_thisCommand, actionCommand) => assertRegionIsValid(actionCommand.args[1]));
-    flySetupCommand.hook("preAction", (_thisCommand, actionCommand) => assertRegionIsValid(actionCommand.args[1]));
-    createFlyDbCommand.hook("preAction", (_thisCommand, actionCommand) => assertRegionIsValid(actionCommand.args[0]));
+    flyLaunchCommand.hook("preAction", (_thisCommand, actionCommand) => assertRegionIsValid(actionCommand.processedArgs[1]));
+    flySetupCommand.hook("preAction", (_thisCommand, actionCommand) => assertRegionIsValid(actionCommand.processedArgs[1]));
+    createFlyDbCommand.hook("preAction", (_thisCommand, actionCommand) => assertRegionIsValid(actionCommand.processedArgs[0]));
     return fly;
 }
 function makeFlyLaunchCommand() {

package/data/packages/deploy/dist/providers/railway/commands/setup/setup.js

@@ -7,8 +7,10 @@ import { createCommandWithCwd } from "../../../../common/zx.js";
 import { createDeploymentInstructions, } from "../../DeploymentInstructions.js";
 import { getRailwayEnvVarValueReference } from "../../env.js";
 import { clientAppPort, serverAppPort } from "../../ports.js";
+import { getLinkedEnvironmentId } from "../../railwayEnvironment/cli.js";
 import { initRailwayProject, linkRailwayProjectToWaspProjectDir, } from "../../railwayProject/cli.js";
 import { getRailwayProjectStatus, ProjectStatus, } from "../../railwayProject/index.js";
+import { assertDatabaseServiceHasVolume, createDatabaseService, } from "../../railwayService/database.js";
 import { waitForServiceDeploymentSuccess } from "../../railwayService/deployment.js";
 import { generateServiceUrl } from "../../railwayService/url.js";
 export async function setup(projectName, options) {
@@ -22,8 +24,10 @@ export async function setup(projectName, options) {
         workspace: options.workspace,
     });
     await ensureWaspProjectIsBuilt(options);
-    if (project.doesServiceExist(deploymentInstructions.dbServiceName)) {
-        waspSays("Postgres service already exists. Skipping database setup.");
+    const dbService = project.findService(deploymentInstructions.dbServiceName);
+    if (dbService) {
+        waspSays("Postgres service already exists. Skipping database creation.");
+        await assertDatabaseServiceHasVolume(dbService, options.dbVolumeMountPath, options);
     }
     else {
         await setupDb(deploymentInstructions);
@@ -72,39 +76,23 @@ async function setupRailwayProjectForDirectory({ railwayExe, projectName, waspPr
     }
 }
 async function setupDb({ cmdOptions: options, dbServiceName, }) {
-    waspSays("Setting up database");
-    const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
-    if (options.dbImage) {
-        waspSays(`Using custom database image: ${options.dbImage}`);
-        // When using a custom database image, Railway doesn't automatically set the default
-        // Postgres-related environment variables, so we need to set them ourselves.
-        await railwayCli([
-            "add",
-            ...["--service", dbServiceName],
-            ...["--image", options.dbImage],
-            ...["--variables", "POSTGRES_DB=railway"],
-            ...["--variables", "POSTGRES_USER=postgres"],
-            ...[
-                "--variables",
-                `POSTGRES_PASSWORD=${getRailwayEnvVarValueReference("secret()")}`,
-            ],
-            ...["--variables", "PORT=5432"],
-            ...["--variables", "PGDATA=/var/lib/postgresql/data/pgdata"],
-            ...[
-                "--variables",
-                `DATABASE_URL=postgresql://${getRailwayEnvVarValueReference("POSTGRES_USER")}:${getRailwayEnvVarValueReference("POSTGRES_PASSWORD")}@${getRailwayEnvVarValueReference("RAILWAY_PRIVATE_DOMAIN")}:${getRailwayEnvVarValueReference("PORT")}/${getRailwayEnvVarValueReference("POSTGRES_DB")}`,
-            ],
-        ]);
-    }
-    else {
-        // Use the default Railway Postgres template.
-        await railwayCli(["add", "-d", "postgres"]);
-    }
+    waspSays(`Setting up database using image: ${options.dbImage}`);
+    const environmentId = await getLinkedEnvironmentId(options);
+    const dbService = await createDatabaseService({
+        serviceName: dbServiceName,
+        imageSpec: {
+            image: options.dbImage,
+            volumeMountPath: options.dbVolumeMountPath,
+        },
+        environmentId,
+        railwayExe: options.railwayExe,
+        waspProjectDir: options.waspProjectDir,
+    });
     // The database service deploys asynchronously and `railway add` doesn't wait
     // for it. The server service references the database's DATABASE_URL env
     // variable, and Railway references to a service that isn't fully set up
     // silently resolve to an empty string and never recover.
-    await waitForServiceDeploymentSuccess(dbServiceName, options);
+    await waitForServiceDeploymentSuccess(dbService, options);
 }
 async function setupServer({ cmdOptions: options, serverServiceName, clientServiceName, dbServiceName, }) {
     waspSays(`Setting up server app with name ${serverServiceName}`);

package/data/packages/deploy/dist/providers/railway/index.js

@@ -5,6 +5,12 @@ import { launch as launchFn } from "./commands/launch/launch.js";
 import { setup as setupFn } from "./commands/setup/setup.js";
 import { assertRailwayProjectNameIsValid, ensureRailwayCliReady, } from "./railwayCli.js";
 import { retryOnRailwayAPIError } from "./retry.js";
+// Pinned to the same Postgres major as Wasp's dev database. Keep in sync with
+// Wasp.Db.Postgres.defaultPostgresDockerImageSpec.
+const defaultDbOptions = {
+    image: "ghcr.io/railwayapp-templates/postgres-ssl:18",
+    volumeMountPath: "/var/lib/postgresql/data",
+};
 class RailwayCommand extends Command {
     addProjectNameArgument() {
         return this.argument("<project-name>", "project name to use on Railway");
@@ -18,6 +24,9 @@ class RailwayCommand extends Command {
     addCustomServerUrlOption() {
         return this.option("--custom-server-url <url>", "URL of the server that the client will connect to");
     }
+    addDbOptions() {
+        return this.option("--db-image <dbImage>", "Docker image for the PostgreSQL database", defaultDbOptions.image).option("--db-volume-mount-path <dbVolumeMountPath>", "Path inside the PostgreSQL container where the volume is mounted", defaultDbOptions.volumeMountPath);
+    }
 }
 export const railwaySetupCommand = makeRailwaySetupCommand();
 export const railwayDeployCommand = makeRailwayDeployCommand();
@@ -62,7 +71,7 @@ function makeRailwaySetupCommand() {
         .addSecretsOptions()
         .option("--existing-project-id [projectId]", "use existing project instead of creating a new one")
         .option("--workspace [workspace]", "the Railway workspace to use if a new project needs to be created (if not provided, will ask interactively)")
-        .option("--db-image <dbImage>", "custom Docker image for the PostgreSQL database")
+        .addDbOptions()
         .action((...args) => retryOnRailwayAPIError(() => setupFn(...args)));
 }
 function makeRailwayDeployCommand() {
@@ -82,7 +91,7 @@ function makeRailwayLaunchCommand() {
         .addSecretsOptions()
         .option("--existing-project-id [projectId]", "use existing project instead of creating a new one")
         .option("--workspace [workspace]", "the Railway workspace to use if a new project needs to be created (if not provided, will ask interactively)")
-        .option("--db-image <dbImage>", "custom Docker image for the PostgreSQL database")
+        .addDbOptions()
         .addCustomServerUrlOption()
         .action(launchFn);
 }