@wasp.sh/wasp-cli-darwin-x64-unknown 0.20.0

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

@@ -0,0 +1,57 @@
+import { getFullCommandName } from "../../../../common/commander.js";
+import { waspSays } from "../../../../common/terminal.js";
+import { ensureWaspProjectIsBuilt } from "../../../../common/waspBuild.js";
+import { createDeploymentInstructions } from "../../DeploymentInstructions.js";
+import { railwaySetupCommand } from "../../index.js";
+import { linkRailwayProjectToWaspProjectDir } from "../../railwayProject/cli.js";
+import { getRailwayProjectStatus, ProjectStatus, } from "../../railwayProject/index.js";
+import { deployClient } from "./client.js";
+import { deployServer } from "./server.js";
+export async function deploy(projectName, options) {
+    const deploymentInstructions = createDeploymentInstructions(projectName, options);
+    await ensureRailwayProjectForDirectory({
+        projectName,
+        waspProjectDir: options.waspProjectDir,
+        existingProjectId: options.existingProjectId,
+        railwayExe: options.railwayExe,
+    });
+    waspSays("Deploying your Wasp app to Railway!");
+    await ensureWaspProjectIsBuilt(options);
+    if (options.skipServer) {
+        waspSays("Skipping server deploy due to CLI option.");
+    }
+    else {
+        await deployServer(deploymentInstructions);
+    }
+    if (options.skipClient) {
+        waspSays("Skipping client deploy due to CLI option.");
+    }
+    else {
+        await deployClient(deploymentInstructions);
+    }
+}
+async function ensureRailwayProjectForDirectory({ railwayExe, projectName, waspProjectDir, existingProjectId, }) {
+    const { status, project } = await getRailwayProjectStatus({
+        projectName,
+        waspProjectDir,
+        railwayExe,
+        existingProjectId,
+    });
+    switch (status) {
+        case ProjectStatus.EXISTING_PROJECT_ALREADY_LINKED:
+            waspSays(`Using already linked project: "${projectName}"`);
+            return project;
+        case ProjectStatus.EXISTING_PROJECT_SHOULD_BE_LINKED:
+            waspSays(`Linking Railway project with name "${project.name}" to project directory.`);
+            return linkRailwayProjectToWaspProjectDir(project, {
+                railwayExe,
+                waspProjectDir,
+            });
+        case ProjectStatus.MISSING_PROJECT:
+            throw new Error(`No Railway project found. Run ${getFullCommandName(railwaySetupCommand)} first or provide an existing project ID with "--existing-project-id" option.`);
+        default:
+            status;
+            throw new Error(`Unhandled status: ${status}`);
+    }
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,17 @@
+import { waspSays } from "../../../../common/terminal.js";
+import { getServerBuildArtefactsDir } from "../../../../common/waspProject.js";
+import { deployServiceWithStreamingLogs, ServiceDeploymentStatus, } from "./common.js";
+export async function deployServer({ cmdOptions: options, serverServiceName, }) {
+    waspSays("Deploying your server now...");
+    const serverBuildArtefactsDir = getServerBuildArtefactsDir(options.waspProjectDir);
+    const deploymentStatus = await deployServiceWithStreamingLogs({
+        name: serverServiceName,
+        dirToDeploy: serverBuildArtefactsDir,
+    }, options);
+    const messages = {
+        [ServiceDeploymentStatus.SUCCESS]: "Server has been deployed!",
+        [ServiceDeploymentStatus.FAILED_TO_STREAM_LOGS]: "Server deployment started, but failed to stream build logs. Please check the Railway dashboard for build logs.",
+    };
+    waspSays(messages[deploymentStatus]);
+}
+//# sourceMappingURL=server.js.map

package/data/packages/deploy/dist/providers/railway/commands/launch/LaunchCmdOptions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LaunchCmdOptions.js.map

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

@@ -0,0 +1,9 @@
+import { waspSays } from "../../../../common/terminal.js";
+import { deploy } from "../deploy/index.js";
+import { setup } from "../setup/setup.js";
+export async function launch(projectName, options) {
+    waspSays("Launching your Wasp app to Railway!");
+    await setup(projectName, options);
+    await deploy(projectName, options);
+}
+//# sourceMappingURL=launch.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SetupCmdOptions.js.map

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

@@ -0,0 +1,146 @@
+import { $ } from "zx";
+import { generateRandomHexString } from "../../../../common/random.js";
+import { waspSays } from "../../../../common/terminal.js";
+import { ensureWaspProjectIsBuilt } from "../../../../common/waspBuild.js";
+import { getClientBuildDir, getServerBuildDir, } from "../../../../common/waspProject.js";
+import { createCommandWithCwd } from "../../../../common/zx.js";
+import { createDeploymentInstructions, } from "../../DeploymentInstructions.js";
+import { clientAppPort, serverAppPort } from "../../ports.js";
+import { initRailwayProject, linkRailwayProjectToWaspProjectDir, } from "../../railwayProject/cli.js";
+import { getRailwayProjectStatus, ProjectStatus, } from "../../railwayProject/index.js";
+import { generateServiceUrl } from "../../railwayService/url.js";
+export async function setup(projectName, options) {
+    waspSays("Setting up your Wasp app with Railway!");
+    const deploymentInstructions = createDeploymentInstructions(projectName, options);
+    const project = await setupRailwayProjectForDirectory({
+        projectName,
+        existingProjectId: options.existingProjectId,
+        waspProjectDir: options.waspProjectDir,
+        railwayExe: options.railwayExe,
+        workspace: options.workspace,
+    });
+    await ensureWaspProjectIsBuilt(options);
+    if (project.doesServiceExist(deploymentInstructions.dbServiceName)) {
+        waspSays("Postgres service already exists. Skipping database setup.");
+    }
+    else {
+        await setupDb(deploymentInstructions);
+    }
+    if (project.doesServiceExist(deploymentInstructions.clientServiceName)) {
+        waspSays("Client service already exists. Skipping client setup.");
+    }
+    else {
+        await setupClient(deploymentInstructions);
+    }
+    if (project.doesServiceExist(deploymentInstructions.serverServiceName)) {
+        waspSays("Server service already exists. Skipping server setup.");
+    }
+    else {
+        await setupServer(deploymentInstructions);
+    }
+}
+async function setupRailwayProjectForDirectory({ railwayExe, projectName, waspProjectDir, existingProjectId, workspace, }) {
+    const { status, project } = await getRailwayProjectStatus({
+        projectName,
+        waspProjectDir,
+        railwayExe,
+        existingProjectId,
+    });
+    switch (status) {
+        case ProjectStatus.EXISTING_PROJECT_ALREADY_LINKED:
+            waspSays(`Project with name "${projectName}" already linked. Skipping project creation.`);
+            return project;
+        case ProjectStatus.EXISTING_PROJECT_SHOULD_BE_LINKED:
+            waspSays(`Linking project with name "${project.name}" to this directory`);
+            return linkRailwayProjectToWaspProjectDir(project, {
+                railwayExe,
+                waspProjectDir,
+            });
+        case ProjectStatus.MISSING_PROJECT:
+            waspSays(`Setting up Railway project with name "${projectName}"`);
+            return initRailwayProject({
+                projectName,
+                railwayExe,
+                waspProjectDir,
+                workspace,
+            });
+        default:
+            status;
+            throw new Error(`Unhandled status: ${status}`);
+    }
+}
+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"]);
+    }
+}
+async function setupServer({ cmdOptions: options, serverServiceName, clientServiceName, dbServiceName, }) {
+    waspSays(`Setting up server app with name ${serverServiceName}`);
+    // The client service needs a URL so it can be referenced in the
+    // server service env variables.
+    await generateServiceUrl(clientServiceName, clientAppPort, options);
+    const serverBuildDir = getServerBuildDir(options.waspProjectDir);
+    const railwayCli = createCommandWithCwd(options.railwayExe, serverBuildDir);
+    const clientUrl = `https://${getRailwayEnvVarValueReference(`${clientServiceName}.RAILWAY_PUBLIC_DOMAIN`)}`;
+    // If we reference the service URL in its OWN env variables, we don't prefix it with the service name.
+    const serverUrl = `https://${getRailwayEnvVarValueReference("RAILWAY_PUBLIC_DOMAIN")}`;
+    const databaseUrl = getRailwayEnvVarValueReference(`${dbServiceName}.DATABASE_URL`);
+    const jwtSecret = generateRandomHexString();
+    await railwayCli([
+        "add",
+        ["--service", serverServiceName],
+        ["--variables", `PORT=${serverAppPort}`],
+        ["--variables", `JWT_SECRET=${jwtSecret}`],
+        ["--variables", `WASP_SERVER_URL=${serverUrl}`],
+        ["--variables", `WASP_WEB_CLIENT_URL=${clientUrl}`],
+        ["--variables", `DATABASE_URL=${databaseUrl}`],
+        ...options.serverSecret.map((secret) => ["--variables", secret]),
+    ].flat());
+    // The server service needs a URL so it can be referenced in the
+    // env variables, we can only generate it after the service is created.
+    await generateServiceUrl(serverServiceName, serverAppPort, options);
+    waspSays("Server setup complete!");
+}
+async function setupClient({ cmdOptions: options, clientServiceName, }) {
+    waspSays(`Setting up client app with name ${clientServiceName}`);
+    const clientBuildDir = getClientBuildDir(options.waspProjectDir);
+    const railwayCli = createCommandWithCwd(options.railwayExe, clientBuildDir);
+    // Having a Staticfile tells Railway to use a static file server.
+    await $({ cwd: clientBuildDir }) `touch Staticfile`;
+    await railwayCli([
+        "add",
+        ["--service", clientServiceName],
+        ["--variables", `PORT=${clientAppPort}`],
+        ...options.clientSecret.map((secret) => ["--variables", secret]),
+    ].flat());
+    waspSays("Client setup complete!");
+}
+function getRailwayEnvVarValueReference(name) {
+    return "${{" + name + "}}";
+}
+//# sourceMappingURL=setup.js.map

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

@@ -0,0 +1,83 @@
+import { Command, Option } from "commander";
+import { assertValidWaspProject, assertWaspProjectDirIsAbsoluteAndPresent, } from "../../common/waspProject.js";
+import { deploy as deployFn } from "./commands/deploy/index.js";
+import { launch as launchFn } from "./commands/launch/launch.js";
+import { setup as setupFn } from "./commands/setup/setup.js";
+import { assertRailwayProjectNameIsValid, ensureRailwayCliReady, } from "./railwayCli.js";
+class RailwayCommand extends Command {
+    addProjectNameArgument() {
+        return this.argument("<project-name>", "project name to use on Railway");
+    }
+    addSecretsOptions() {
+        function collect(value, previous) {
+            return previous.concat([value]);
+        }
+        return this.option("--server-secret <serverSecret>", "secret to set on the server app (of form FOO=BAR)", collect, []).option("--client-secret <clientSecret>", "secret to set on the client app (of form FOO=BAR)", collect, []);
+    }
+}
+export const railwaySetupCommand = makeRailwaySetupCommand();
+export const railwayDeployCommand = makeRailwayDeployCommand();
+const railwayLaunchCommand = makeRailwayLaunchCommand();
+export function createRailwayCommand() {
+    const railway = new Command("railway")
+        .description("Create and deploy Wasp apps on Railway")
+        .addCommand(railwaySetupCommand)
+        .addCommand(railwayDeployCommand)
+        .addCommand(railwayLaunchCommand)
+        .allowUnknownOption();
+    // Add global options and hooks to all commands.
+    // Add these hooks before any command-specific ones so they run first.
+    // NOTE: When we add another provider, consider pulling `--wasp-exe` and `--wasp-project-dir`
+    // up as a global option that every provider can use (if possible).
+    railway.commands.forEach((cmd) => {
+        cmd
+            .addOption(new Option("--wasp-exe <path>", "Wasp executable (either on PATH or absolute path)")
+            .hideHelp()
+            .makeOptionMandatory())
+            .addOption(new Option("--wasp-project-dir <dir>", "absolute path to Wasp project dir")
+            .hideHelp()
+            .makeOptionMandatory())
+            .addOption(new Option("--railway-exe <path>", "Railway command to run (either on PATH or absolute path)")
+            .hideHelp()
+            .default("railway"))
+            .hook("preAction", async (cmd) => {
+            const { waspProjectDir, waspExe, railwayExe } = cmd.opts();
+            const railwayProjectName = cmd.args[0];
+            await ensureRailwayCliReady(railwayExe);
+            assertRailwayProjectNameIsValid(railwayProjectName);
+            assertWaspProjectDirIsAbsoluteAndPresent(waspProjectDir);
+            await assertValidWaspProject(waspProjectDir, waspExe);
+        });
+    });
+    return railway;
+}
+function makeRailwaySetupCommand() {
+    return new RailwayCommand("setup")
+        .description("Configure a new app on Railway")
+        .addProjectNameArgument()
+        .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")
+        .action(setupFn);
+}
+function makeRailwayDeployCommand() {
+    return new RailwayCommand("deploy")
+        .description("Deploys the app to Railway")
+        .addProjectNameArgument()
+        .option("--skip-client", "do not deploy the web client")
+        .option("--skip-server", "do not deploy the server")
+        .option("--existing-project-id [projectId]", "use existing project for deployment")
+        .action(deployFn);
+}
+function makeRailwayLaunchCommand() {
+    return new RailwayCommand("launch")
+        .description("Launch a new app on Railway (calls setup and deploy)")
+        .addProjectNameArgument()
+        .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")
+        .action(launchFn);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,19 @@
+import * as z from "zod";
+export const RailwayCliServiceSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+});
+export const RailwayCliProjectSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    services: z.object({
+        edges: z.array(z.object({
+            node: RailwayCliServiceSchema,
+        })),
+    }),
+});
+export const RailwayProjectListSchema = z.array(RailwayCliProjectSchema);
+export const RailwayCliDomainSchema = z.object({
+    domain: z.string(),
+});
+//# sourceMappingURL=jsonOutputSchemas.js.map

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

@@ -0,0 +1,6 @@
+// Ports we decided to use for the server and client apps.
+// These are arbitrary values that are used internally by
+// Railway containers to run the apps.
+export const serverAppPort = 8080;
+export const clientAppPort = 8080;
+//# sourceMappingURL=ports.js.map

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

@@ -0,0 +1,85 @@
+import semver, { SemVer } from "semver";
+import { $ } from "zx";
+import { confirm } from "@inquirer/prompts";
+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");
+export async function ensureRailwayCliReady(railwayExe) {
+    const railwayCliVersion = await getRailwayCliVersion(railwayExe);
+    assertUsingMinimumSupportedRailwayCliVersion(railwayCliVersion);
+    await ensureUserLoggedIn(railwayExe);
+}
+async function ensureUserLoggedIn(railwayExe) {
+    const userLoggedIn = await isUserLoggedIn(railwayExe);
+    if (userLoggedIn) {
+        return;
+    }
+    await confirmUserWantsToLogin();
+    await loginToRailway(railwayExe);
+}
+async function isUserLoggedIn(railwayExe) {
+    const result = await $({ nothrow: true }) `${railwayExe} whoami`;
+    return result.exitCode === 0;
+}
+async function confirmUserWantsToLogin() {
+    const wantsToLogin = await confirm({
+        message: "You are not logged into Railway. Would you like to log in now?",
+    });
+    if (!wantsToLogin) {
+        throw new Error("Unable to continue without logging in to Railway.");
+    }
+}
+async function loginToRailway(railwayExe) {
+    // Login comand requires **interactive** terminal.
+    const loginCmdOptions = {
+        stdio: "inherit",
+    };
+    await $(loginCmdOptions) `${railwayExe} login`;
+}
+async function getRailwayCliVersion(railwayExe) {
+    const result = await $({ nothrow: true }) `${railwayExe} -V`;
+    if (result.exitCode !== 0) {
+        throw new Error([
+            "Failed to get Railway CLI version. Most likely the Railway CLI is not installed.",
+            "Read how to install the Railway CLI here: https://docs.railway.com/guides/cli",
+        ].join("\n"));
+    }
+    const match = result.stdout.match(/railway(?:app)? (.*)/);
+    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);
+    }
+}
+export function assertRailwayProjectNameIsValid(projectName) {
+    const maximumProjectNameLength = getMaximumProjectNameLength();
+    if (projectName.length > maximumProjectNameLength) {
+        throw new Error(`The project name "${projectName}" is too long (${projectName.length} characters). It must be at most ${maximumProjectNameLength} characters long.`);
+    }
+}
+function getMaximumProjectNameLength() {
+    // Railway has a limit of 32 characters for the service name.
+    // https://docs.railway.com/reference/services#constraints
+    const maximumServiceNameLength = 32;
+    // We construct service names by appending suffixes to the project name:
+    // ServiceNameLength = ProjectNameLength + SuffixLength.
+    return maximumServiceNameLength - getMaximumServiceSuffixLength();
+}
+function getMaximumServiceSuffixLength() {
+    return Math.max(...Object.values(serviceNameSuffixes).map((s) => s.length));
+}
+//# sourceMappingURL=railwayCli.js.map

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

@@ -0,0 +1,14 @@
+export function createRailwayProject(cliProject) {
+    return {
+        id: cliProject.id,
+        name: cliProject.name,
+        services: cliProject.services.edges.map((edge) => ({
+            id: edge.node.id,
+            name: edge.node.name,
+        })),
+        doesServiceExist(serviceName) {
+            return this.services.some((s) => s.name === serviceName);
+        },
+    };
+}
+//# sourceMappingURL=RailwayProject.js.map

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

@@ -0,0 +1,80 @@
+import { $ } from "zx";
+import { waspSays } from "../../../common/terminal.js";
+import { createCommandWithCwd } from "../../../common/zx.js";
+import { RailwayCliProjectSchema, RailwayProjectListSchema, } from "../jsonOutputSchemas.js";
+import { createRailwayProject } from "./RailwayProject.js";
+/**
+ * Initializing a Railway project means creating a new project
+ * in Railway platform and linking it to the current
+ * Wasp project directory.
+ */
+export async function initRailwayProject({ projectName, railwayExe, waspProjectDir, workspace, }) {
+    const railwayCli = createCommandWithCwd(railwayExe, waspProjectDir);
+    const workspaceArgs = workspace ? ["--workspace", workspace] : [];
+    await railwayCli(["init", "--name", projectName, ...workspaceArgs], {
+        // If there are multiple workspaces and the user has not specified which one
+        // they want, the CLI will ask for it **interactively**, so we need users to
+        // be able to interact with the command.
+        stdio: "inherit",
+    });
+    // Check if the project was created successfully...
+    const newRailwayProject = await getRailwayProjectForDirectory(railwayExe, waspProjectDir);
+    if (newRailwayProject === null) {
+        throw new Error("Railway project creation failed.");
+    }
+    waspSays("Railway project created successfully!");
+    return newRailwayProject;
+}
+/**
+ * Linking a Railway project means associating an existing
+ * Railway project with the current Wasp project directory.
+ */
+export async function linkRailwayProjectToWaspProjectDir(project, { railwayExe, waspProjectDir, }) {
+    const railwayCli = createCommandWithCwd(railwayExe, waspProjectDir);
+    // Railway CLI quirk, if the project has services, we need to specify one of them,
+    // otherwise Railway will ask for it interactively. (Even though we are linking
+    // a project and not a service.)
+    const serviceArg = project.services.length > 0 ? ["-s", project.services[0].name] : [];
+    await railwayCli(["link", "-p", project.name, ...serviceArg]);
+    // Sometimes linking fails silently, so we need to check if the project
+    // was linked successfully.
+    const linkedRailwayProject = await getRailwayProjectForDirectory(railwayExe, waspProjectDir);
+    if (linkedRailwayProject === null || linkedRailwayProject.id !== project.id) {
+        throw new Error("Railway project linking failed.");
+    }
+    waspSays("Railway project linked successfully!");
+    return linkedRailwayProject;
+}
+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 {
+        return null;
+    }
+}
+export async function getRailwayProjectById(railwayExe, id) {
+    const projects = await getRailwayProjects(railwayExe);
+    return projects.find((project) => project.id === id) ?? null;
+}
+export async function getRailwayProjectByName(railwayExe, name) {
+    const projects = await getRailwayProjects(railwayExe);
+    return projects.find((project) => project.name === name) ?? null;
+}
+// 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));
+    return projects.map((cliProject) => {
+        return createRailwayProject(cliProject);
+    });
+}
+//# sourceMappingURL=cli.js.map

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

@@ -0,0 +1,48 @@
+import { getRailwayProjectById, getRailwayProjectByName, getRailwayProjectForDirectory, } from "./cli.js";
+export var ProjectStatus;
+(function (ProjectStatus) {
+    ProjectStatus["EXISTING_PROJECT_ALREADY_LINKED"] = "EXISTING_PROJECT_ALREADY_LINKED";
+    ProjectStatus["EXISTING_PROJECT_SHOULD_BE_LINKED"] = "EXISTING_PROJECT_SHOULD_BE_LINKED";
+    ProjectStatus["MISSING_PROJECT"] = "MISSING_PROJECT";
+})(ProjectStatus || (ProjectStatus = {}));
+export async function getRailwayProjectStatus({ projectName, waspProjectDir, railwayExe, existingProjectId, }) {
+    const projectLinkedToDir = await getRailwayProjectForDirectory(railwayExe, waspProjectDir);
+    if (projectLinkedToDir !== null) {
+        await assertProvidedProjectNameSameAsExistingProjectName(projectLinkedToDir, projectName);
+        return {
+            status: ProjectStatus.EXISTING_PROJECT_ALREADY_LINKED,
+            project: projectLinkedToDir,
+        };
+    }
+    if (existingProjectId) {
+        const existingProject = await getExistingProjectById(railwayExe, existingProjectId);
+        return {
+            status: ProjectStatus.EXISTING_PROJECT_SHOULD_BE_LINKED,
+            project: existingProject,
+        };
+    }
+    await assertUniqueProjectName(railwayExe, projectName);
+    return {
+        status: ProjectStatus.MISSING_PROJECT,
+        project: null,
+    };
+}
+async function getExistingProjectById(railwayExe, existingProjectId) {
+    const projectById = await getRailwayProjectById(railwayExe, existingProjectId);
+    if (projectById === null) {
+        throw new Error(`Project with ID "${existingProjectId}" does not exist.`);
+    }
+    return projectById;
+}
+async function assertProvidedProjectNameSameAsExistingProjectName(project, projectName) {
+    if (project.name !== projectName) {
+        throw new Error(`Project with a different name already linked to this directory: "${project.name}". Run "railway unlink" to unlink it.`);
+    }
+}
+async function assertUniqueProjectName(railwayExe, projectName) {
+    const project = await getRailwayProjectByName(railwayExe, projectName);
+    if (project !== null) {
+        throw new Error(`Project with name "${project.name}" already exists. Add "--existing-project-id ${project.id}" option to this command to link it or use a different name.`);
+    }
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,24 @@
+export function createRailwayClientServiceName(projectName) {
+    return createRailwayServiceName(projectName, ServiceWithSuffixedName.Client);
+}
+export function createRailwayServerServiceName(projectName) {
+    return createRailwayServiceName(projectName, ServiceWithSuffixedName.Server);
+}
+function createRailwayServiceName(projectName, service) {
+    const serviceNameSuffix = serviceNameSuffixes[service];
+    return `${projectName}${serviceNameSuffix}`;
+}
+var ServiceWithSuffixedName;
+(function (ServiceWithSuffixedName) {
+    ServiceWithSuffixedName["Client"] = "Client";
+    ServiceWithSuffixedName["Server"] = "Server";
+})(ServiceWithSuffixedName || (ServiceWithSuffixedName = {}));
+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/url.js

@@ -0,0 +1,32 @@
+import { createCommandWithCwd } 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) {
+        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);
+    }
+    else {
+        return RailwayCliDomainSchema.parse(result.json()).domain;
+    }
+}
+function extractServiceUrlFromString(text) {
+    const match = text.match(/https:\/\/[^\s]*/);
+    if (match === null) {
+        throw new Error("Failed to get service domain");
+    }
+    return match[0];
+}
+//# sourceMappingURL=url.js.map