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

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

@@ -13,6 +13,18 @@ export const RailwayCliProjectSchema = z.object({
     }),
 });
 export const RailwayProjectListSchema = z.array(RailwayCliProjectSchema);
+export const RailwayCliEnvironmentListSchema = z.object({
+    environments: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        isLinked: z.boolean(),
+    })),
+});
+export const RailwayCliServiceListSchema = z.array(RailwayCliServiceSchema.extend({
+    volumes: z.array(z.object({
+        mountPath: z.string(),
+    })),
+}));
 export const DeploymentStatusSchema = z.enum([
     "BUILDING",
     "CRASHED",
@@ -28,45 +40,18 @@ export const DeploymentStatusSchema = z.enum([
     "SUCCESS",
     "WAITING",
 ]);
-const GroupedServiceInstancesSchema = z.object({
-    edges: z.array(z.object({
-        node: z.object({
-            serviceInstances: z.object({
-                edges: z.array(z.object({
-                    node: z.object({
-                        serviceName: z.string(),
-                        latestDeployment: z
-                            .object({
-                            status: DeploymentStatusSchema,
-                        })
-                            .nullish(),
-                    }),
-                })),
-            }),
-        }),
-    })),
+export const RailwayCliServiceStatusSchema = z.object({
+    // A missing status (service never deployed) or an unrecognized status
+    // defaults to `null`.
+    status: DeploymentStatusSchema.nullable().catch(null).default(null),
 });
-// Railway CLI >=4.35 nests service instances under `environments`.
-const NewFormatProjectStatusSchema = z.object({
-    environments: GroupedServiceInstancesSchema,
-});
-// Older Railway CLI versions (e.g. 4.11) nest service instances under `services`.
-const OldFormatProjectStatusSchema = z.object({
-    services: GroupedServiceInstancesSchema,
-});
-export const RailwayCliProjectStatusSchema = z.union([
-    NewFormatProjectStatusSchema,
-    OldFormatProjectStatusSchema.transform(({ services }) => ({
-        environments: services,
-    })),
-]);
 export const RailwayCliDomainSchema = z.union([
-    // Railway CLI >=4.18.1
+    // `railway domain` prints all existing domains when the service already
+    // has one...
     z.object({ domains: z.array(z.string()).min(1) }),
-    // Railway CLI <4.18.1
+    // ...and just the new domain when it creates it.
     z
         .object({ domain: z.string() })
-        // Convert to the newer format
         .transform(({ domain }) => ({ domains: [domain] })),
 ]);
 //# sourceMappingURL=jsonOutputSchemas.js.map

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

@@ -1,14 +1,18 @@
-import semver, { SemVer } from "semver";
+import { SemVer } from "semver";
 import { $ } from "zx";
 import { confirm } from "@inquirer/prompts";
+import { assertCliVersionMeetsMinimum, parseCliVersion, } from "../../common/cliVersion.js";
 import { serviceNameSuffixes } from "./railwayService/nameGenerator.js";
-// Railway CLI version 4.0.1 includes a change that is needed for
-// Wasp deploy command to work with Railway properly:
-// https://github.com/railwayapp/cli/pull/596
-const minSupportedRailwayCliVersion = new SemVer("4.6.3");
+// Wasp relies on the `railway api` command added in Railway CLI 5.28.0.
+const minSupportedRailwayCliVersion = new SemVer("5.28.0");
 export async function ensureRailwayCliReady(railwayExe) {
     const railwayCliVersion = await getRailwayCliVersion(railwayExe);
-    assertUsingMinimumSupportedRailwayCliVersion(railwayCliVersion);
+    assertCliVersionMeetsMinimum({
+        cliName: "Railway CLI",
+        currentVersion: railwayCliVersion,
+        minimumVersion: minSupportedRailwayCliVersion,
+        updateInstructions: "Read how to update the Railway CLI here: https://docs.railway.com/guides/cli",
+    });
     await ensureUserLoggedIn(railwayExe);
 }
 async function ensureUserLoggedIn(railwayExe) {
@@ -50,20 +54,7 @@ async function getRailwayCliVersion(railwayExe) {
     if (match === null) {
         throw new Error(`Failed to get Railway CLI version from output "${result.stdout.trim()}".`);
     }
-    const version = semver.parse(match[1]);
-    if (version === null) {
-        throw new Error(`Unable to parse Railway CLI version "${match[1]}".`);
-    }
-    return version;
-}
-function assertUsingMinimumSupportedRailwayCliVersion(railwayCliVersion) {
-    if (!semver.gte(railwayCliVersion, minSupportedRailwayCliVersion)) {
-        const message = [
-            `Wasp expects at least Railway CLI version ${minSupportedRailwayCliVersion}.`,
-            "Read how to update the Railway CLI here: https://docs.railway.com/guides/cli",
-        ].join("\n");
-        throw new Error(message);
-    }
+    return parseCliVersion("Railway CLI", match[1]);
 }
 export function assertRailwayProjectNameIsValid(projectName) {
     const maximumProjectNameLength = getMaximumProjectNameLength();

package/data/packages/deploy/dist/providers/railway/railwayEnvironment/cli.js

@@ -0,0 +1,20 @@
+import { createCommandWithCwd, runJsonCommand } from "../../../common/zx.js";
+import { RailwayCliEnvironmentListSchema } from "../jsonOutputSchemas.js";
+// `railway status --json` returns all of the project's environments without
+// saying which one is linked, so we ask `railway environment list` instead.
+export async function getLinkedEnvironmentId(options) {
+    const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
+    const { environments } = await runJsonCommand(railwayCli, ["environment", "list", "--json"], RailwayCliEnvironmentListSchema);
+    const linkedEnvironment = environments.find((environment) => environment.isLinked);
+    // We don't expect this to happen in a normally provisioned Railway project:
+    // `railway init` creates a default "production" environment and links it,
+    // and `railway link` always selects an environment as well.
+    if (linkedEnvironment === undefined) {
+        const environmentNames = environments
+            .map((environment) => environment.name)
+            .join(", ");
+        throw new Error(`No Railway environment is linked to this directory. Run \`railway environment\` to link one of: ${environmentNames}.`);
+    }
+    return linkedEnvironment.id;
+}
+//# sourceMappingURL=cli.js.map

package/data/packages/deploy/dist/providers/railway/railwayProject/RailwayProject.js

@@ -6,8 +6,11 @@ export function createRailwayProject(cliProject) {
             id: edge.node.id,
             name: edge.node.name,
         })),
+        findService(serviceName) {
+            return this.services.find((service) => service.name === serviceName);
+        },
         doesServiceExist(serviceName) {
-            return this.services.some((s) => s.name === serviceName);
+            return this.findService(serviceName) !== undefined;
         },
     };
 }

package/data/packages/deploy/dist/providers/railway/railwayProject/cli.js

@@ -1,6 +1,5 @@
-import { $ } from "zx";
 import { waspSays } from "../../../common/terminal.js";
-import { createCommandWithCwd } from "../../../common/zx.js";
+import { createCommand, createCommandWithCwd, runJsonCommand, tryRunJsonCommand, } from "../../../common/zx.js";
 import { RailwayCliProjectSchema, RailwayProjectListSchema, } from "../jsonOutputSchemas.js";
 import { createRailwayProject } from "./RailwayProject.js";
 /**
@@ -47,16 +46,11 @@ export async function linkRailwayProjectToWaspProjectDir(project, { railwayExe,
 }
 export async function getRailwayProjectForDirectory(railwayExe, directoryPath) {
     const railwayCli = createCommandWithCwd(railwayExe, directoryPath);
-    const result = await railwayCli(["status", "--json"], {
-        verbose: false,
-        nothrow: true,
-    });
-    if (result.exitCode === 0) {
-        return createRailwayProject(RailwayCliProjectSchema.parse(result.json()));
-    }
-    else {
+    const project = await tryRunJsonCommand(railwayCli, ["status", "--json"], RailwayCliProjectSchema);
+    if (project === null) {
         return null;
     }
+    return createRailwayProject(project);
 }
 export async function getRailwayProjectById(railwayExe, id) {
     const projects = await getRailwayProjects(railwayExe);
@@ -69,10 +63,8 @@ export async function getRailwayProjectByName(railwayExe, name) {
 // TODO: Figure out how to specify the workspace when listing projects.
 // This command lists all projects in all the workspaces the user has access to.
 async function getRailwayProjects(railwayExe) {
-    const result = await $({
-        verbose: false,
-    }) `${railwayExe} list --json`;
-    const projects = RailwayProjectListSchema.parse(JSON.parse(result.stdout));
+    const railwayCli = createCommand(railwayExe);
+    const projects = await runJsonCommand(railwayCli, ["list", "--json"], RailwayProjectListSchema);
     return projects.map((cliProject) => {
         return createRailwayProject(cliProject);
     });

package/data/packages/deploy/dist/providers/railway/railwayService/database.js

@@ -0,0 +1,88 @@
+import { waspSays } from "../../../common/terminal.js";
+import { createCommandWithCwd, runJsonCommand } from "../../../common/zx.js";
+import { getRailwayEnvVarValueReference } from "../env.js";
+import { RailwayCliServiceListSchema, RailwayCliServiceSchema, } from "../jsonOutputSchemas.js";
+import { setServiceInstanceImage, startServiceInstanceDeployment, } from "./serviceInstance.js";
+// Creating a service with an image immediately starts a deployment, and
+// Postgres crashes when its volume isn't attached yet.
+export async function createDatabaseService({ serviceName, imageSpec, environmentId, railwayExe, waspProjectDir, }) {
+    const options = { railwayExe, waspProjectDir };
+    const dbService = await addDatabaseServiceWithoutImage(serviceName, imageSpec.volumeMountPath, options);
+    const dbServiceInstance = {
+        serviceId: dbService.id,
+        environmentId,
+    };
+    try {
+        await addDatabaseVolume(dbService, imageSpec.volumeMountPath, options);
+        await setServiceInstanceImage(dbServiceInstance, imageSpec.image, options);
+        await startServiceInstanceDeployment(dbServiceInstance, options);
+    }
+    catch (setupError) {
+        await deleteIncompleteDatabaseService(dbService, setupError, options);
+        throw setupError;
+    }
+    return dbService;
+}
+export async function assertDatabaseServiceHasVolume(dbService, dbVolumeMountPath, options) {
+    if (!(await hasDatabaseVolume(dbService, dbVolumeMountPath, options))) {
+        throw new Error([
+            `Railway database service "${dbService.name}" (${dbService.id}) has no volume mounted at ${dbVolumeMountPath}.`,
+            "Mounting a volume there now would hide the database's existing data, so Wasp won't do it automatically.",
+            "Back up any existing data before changing the service in Railway. Then add the required volume and restore the backup, or remove the service before trying again.",
+        ].join("\n"));
+    }
+}
+async function addDatabaseServiceWithoutImage(dbServiceName, dbVolumeMountPath, options) {
+    const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
+    // Image-backed services don't get the variables from Railway's Postgres
+    // template, so we configure them explicitly.
+    const dbVariables = {
+        POSTGRES_DB: "railway",
+        POSTGRES_USER: "postgres",
+        POSTGRES_PASSWORD: getRailwayEnvVarValueReference("secret()"),
+        PORT: "5432",
+        // PGDATA must be a subdirectory of the volume mount.
+        PGDATA: `${dbVolumeMountPath}/pgdata`,
+        DATABASE_URL: `postgresql://${getRailwayEnvVarValueReference("POSTGRES_USER")}:${getRailwayEnvVarValueReference("POSTGRES_PASSWORD")}@${getRailwayEnvVarValueReference("RAILWAY_PRIVATE_DOMAIN")}:${getRailwayEnvVarValueReference("PORT")}/${getRailwayEnvVarValueReference("POSTGRES_DB")}`,
+    };
+    const variableArgs = Object.entries(dbVariables).flatMap(([name, value]) => [
+        "--variables",
+        `${name}=${value}`,
+    ]);
+    return runJsonCommand(railwayCli, ["add", ...["--service", dbServiceName], ...variableArgs, "--json"], RailwayCliServiceSchema);
+}
+async function addDatabaseVolume(dbService, dbVolumeMountPath, options) {
+    const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
+    await railwayCli([
+        "volume",
+        ...["--service", dbService.id],
+        "add",
+        ...["--mount-path", dbVolumeMountPath],
+        "--json",
+    ], { verbose: false });
+}
+async function deleteIncompleteDatabaseService(dbService, setupError, options) {
+    const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
+    try {
+        await railwayCli(["service", "delete", ...["--service", dbService.id], "--yes", "--json"], { verbose: false });
+    }
+    catch (cleanupError) {
+        throw new Error([
+            `Wasp couldn't finish setting up Railway database service "${dbService.name}" (${dbService.id}).`,
+            "Wasp also couldn't remove the incomplete service. Remove it from Railway before trying again.",
+            `Setup error: ${getErrorMessage(setupError)}`,
+            `Cleanup error: ${getErrorMessage(cleanupError)}`,
+        ].join("\n"));
+    }
+    waspSays(`Removed incomplete database service "${dbService.name}".`);
+}
+async function hasDatabaseVolume(dbService, dbVolumeMountPath, options) {
+    const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
+    const services = await runJsonCommand(railwayCli, ["service", "list", "--json"], RailwayCliServiceListSchema);
+    return services.some((service) => service.id === dbService.id &&
+        service.volumes.some((volume) => volume.mountPath === dbVolumeMountPath));
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=database.js.map

package/data/packages/deploy/dist/providers/railway/railwayService/deployment.js

@@ -1,45 +1,32 @@
 import { setTimeout } from "node:timers/promises";
 import { waspSays } from "../../../common/terminal.js";
-import { createCommandWithCwd } from "../../../common/zx.js";
-import { RailwayCliProjectStatusSchema, } from "../jsonOutputSchemas.js";
+import { createCommandWithCwd, tryRunJsonCommand } from "../../../common/zx.js";
+import { RailwayCliServiceStatusSchema, } from "../jsonOutputSchemas.js";
 const POLL_INTERVAL_MS = 5000;
 const TIMEOUT_MS = 5 * 60 * 1000;
 // Any other status means the deployment is still in progress.
 const SUCCESS_STATUS = "SUCCESS";
 const FAILURE_STATUSES = ["FAILED", "CRASHED"];
-export async function waitForServiceDeploymentSuccess(serviceName, options) {
+export async function waitForServiceDeploymentSuccess(service, options) {
     const deadline = Date.now() + TIMEOUT_MS;
     while (Date.now() < deadline) {
-        const status = await getLatestServiceDeploymentStatus(serviceName, options);
+        const status = await getLatestServiceDeploymentStatus(service, options);
         if (status === SUCCESS_STATUS) {
             return;
         }
         if (status !== null && FAILURE_STATUSES.includes(status)) {
-            throw new Error(`"${serviceName}" deployment finished with status "${status}". Check the Railway dashboard for details.`);
+            throw new Error(`"${service.name}" deployment finished with status "${status}". Check the Railway dashboard for details.`);
         }
-        waspSays(`Waiting for "${serviceName}" deployment... (Status: "${status ?? "UNKNOWN"}")`);
+        waspSays(`Waiting for "${service.name}" deployment... (Status: "${status ?? "UNKNOWN"}")`);
         await setTimeout(POLL_INTERVAL_MS);
     }
-    throw new Error(`Timed out waiting for "${serviceName}" to be deployed. Check the Railway dashboard for details.`);
+    throw new Error(`Timed out waiting for "${service.name}" to be deployed. Check the Railway dashboard for details.`);
 }
-async function getLatestServiceDeploymentStatus(serviceName, options) {
+async function getLatestServiceDeploymentStatus(service, options) {
     const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
-    const result = await railwayCli(["status", "--json"], {
-        verbose: false,
-        nothrow: true,
-    });
-    if (result.exitCode !== 0) {
-        // Treat transient `railway status` failures as "not ready yet".
-        return null;
-    }
-    const projectStatus = RailwayCliProjectStatusSchema.parse(result.json());
-    return findServiceDeploymentStatus(projectStatus, serviceName);
-}
-export function findServiceDeploymentStatus(projectStatus, serviceName) {
-    const serviceInstance = projectStatus.environments.edges
-        .flatMap((environment) => environment.node.serviceInstances.edges)
-        .map((edge) => edge.node)
-        .find((instance) => instance.serviceName === serviceName);
-    return serviceInstance?.latestDeployment?.status ?? null;
+    const serviceStatus = await tryRunJsonCommand(railwayCli, ["service", "status", "--service", service.id, "--json"], RailwayCliServiceStatusSchema);
+    // Treat a failed command as a transient Railway CLI failure, i.e. "not
+    // ready yet".
+    return serviceStatus?.status ?? null;
 }
 //# sourceMappingURL=deployment.js.map

package/data/packages/deploy/dist/providers/railway/railwayService/nameGenerator.js

@@ -4,6 +4,11 @@ export function createRailwayClientServiceName(projectName) {
 export function createRailwayServerServiceName(projectName) {
     return createRailwayServiceName(projectName, ServiceWithSuffixedName.Server);
 }
+export function createRailwayDbServiceName() {
+    // Kept as "Postgres" for compatibility with databases created by earlier
+    // Wasp versions.
+    return "Postgres";
+}
 function createRailwayServiceName(projectName, service) {
     const serviceNameSuffix = serviceNameSuffixes[service];
     return `${projectName}${serviceNameSuffix}`;
@@ -17,8 +22,4 @@ export const serviceNameSuffixes = {
     [ServiceWithSuffixedName.Client]: "-client",
     [ServiceWithSuffixedName.Server]: "-server",
 };
-export function createRailwayDbServiceName() {
-    // Railway doesn't allow us to choose the database service name.
-    return "Postgres";
-}
 //# sourceMappingURL=nameGenerator.js.map

package/data/packages/deploy/dist/providers/railway/railwayService/serviceInstance.js

@@ -0,0 +1,48 @@
+import * as z from "zod";
+import { createCommandWithCwd, runJsonCommand } from "../../../common/zx.js";
+const RailwayApiServiceInstanceUpdateResponseSchema = z.object({
+    data: z.object({
+        serviceInstanceUpdate: z.literal(true),
+    }),
+});
+export async function setServiceInstanceImage(serviceInstance, image, options) {
+    const serviceInstanceUpdateMutation = `
+    mutation ServiceInstanceUpdate(
+      $serviceId: String!
+      $environmentId: String
+      $input: ServiceInstanceUpdateInput!
+    ) {
+      serviceInstanceUpdate(
+        serviceId: $serviceId
+        environmentId: $environmentId
+        input: $input
+      )
+    }
+  `;
+    const imageSourceInput = JSON.stringify({ input: { source: { image } } });
+    await runServiceInstanceMutation(serviceInstance, serviceInstanceUpdateMutation, ["--variables", imageSourceInput], RailwayApiServiceInstanceUpdateResponseSchema, options);
+}
+const RailwayApiServiceInstanceDeployV2ResponseSchema = z.object({
+    data: z.object({
+        serviceInstanceDeployV2: z.string(),
+    }),
+});
+export async function startServiceInstanceDeployment(serviceInstance, options) {
+    const serviceInstanceDeployV2Mutation = `
+    mutation ServiceInstanceDeployV2($serviceId: String!, $environmentId: String!) {
+      serviceInstanceDeployV2(serviceId: $serviceId, environmentId: $environmentId)
+    }
+  `;
+    await runServiceInstanceMutation(serviceInstance, serviceInstanceDeployV2Mutation, [], RailwayApiServiceInstanceDeployV2ResponseSchema, options);
+}
+async function runServiceInstanceMutation(serviceInstance, mutation, mutationArgs, responseSchema, options) {
+    const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
+    return runJsonCommand(railwayCli, [
+        "api",
+        mutation,
+        ...["--raw-var", `serviceId=${serviceInstance.serviceId}`],
+        ...["--raw-var", `environmentId=${serviceInstance.environmentId}`],
+        ...mutationArgs,
+    ], responseSchema);
+}
+//# sourceMappingURL=serviceInstance.js.map

package/data/packages/deploy/dist/providers/railway/railwayService/url.js

@@ -1,39 +1,18 @@
 import { waspInfo } from "../../../common/terminal.js";
-import { createCommandWithCwd } from "../../../common/zx.js";
+import { createCommandWithCwd, tryRunJsonCommand } from "../../../common/zx.js";
 import { RailwayCliDomainSchema } from "../jsonOutputSchemas.js";
-export var ServiceUrlStatus;
-(function (ServiceUrlStatus) {
-    ServiceUrlStatus["URL_CREATED"] = "URL_CREATED";
-    ServiceUrlStatus["URL_ALREADY_EXISTS"] = "URL_ALREADY_EXISTS";
-})(ServiceUrlStatus || (ServiceUrlStatus = {}));
 export async function generateServiceUrl(serviceName, port, options) {
     const railwayCli = createCommandWithCwd(options.railwayExe, options.waspProjectDir);
-    const result = await railwayCli(["domain", "--service", serviceName, "--port", port.toString(), "--json"], {
-        nothrow: true,
-    });
-    if (result.exitCode !== 0) {
+    const result = await tryRunJsonCommand(railwayCli, ["domain", "--service", serviceName, "--port", port.toString(), "--json"], RailwayCliDomainSchema);
+    if (result === null) {
         throw new Error(`There was a problem getting a domain for ${serviceName}.`);
     }
-    // NOTE: Railway CLI 4.11.2 fixed a typo and we want to stay backwards compatible
-    const domainAlreadyExistsPattern = /Domains already exists? on the service:/;
-    if (domainAlreadyExistsPattern.test(result.stdout)) {
-        return extractServiceUrlFromString(result.stdout);
+    const { domains } = result;
+    const domain = domains[0];
+    if (domains.length > 1) {
+        waspInfo(`Multiple domains detected, using the first one: ${domain}.`);
+        waspInfo('If you want to use a custom domain for the server, you should add the "--custom-server-url <url>" flag.');
     }
-    else {
-        const { domains } = RailwayCliDomainSchema.parse(result.json());
-        const domain = domains[0];
-        if (domains.length > 1) {
-            waspInfo(`Multiple domains detected, using the first one: ${domain}.`);
-            waspInfo('If you want to use a custom domain for the server, you should add the "--custom-server-url <url>" flag.');
-        }
-        return domain;
-    }
-}
-export function extractServiceUrlFromString(text) {
-    const match = text.match(/https:\/\/[^\s]*/);
-    if (match === null) {
-        throw new Error("Failed to get service domain");
-    }
-    return match[0];
+    return domain;
 }
 //# sourceMappingURL=url.js.map

package/data/packages/deploy/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "wasp-deploy",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "wasp-deploy",
-      "version": "0.25.0",
+      "version": "0.26.0",
       "license": "MIT",
       "dependencies": {
         "@inquirer/prompts": "^7.5.3",

package/data/packages/deploy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasp-deploy",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "type": "module",
   "author": "Wasp Team",
   "license": "MIT",

package/data/packages/prisma/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "wasp-prisma",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "wasp-prisma",
-      "version": "0.25.0",
+      "version": "0.26.0",
       "license": "MIT",
       "dependencies": {
         "json5": "^2.2.3",

package/data/packages/prisma/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasp-prisma",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "type": "module",
   "author": "Wasp Team",
   "license": "MIT",