@wasp.sh/wasp-cli-darwin-arm64-unknown 0.21.1 → 0.22.0-rc1

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

@@ -1,38 +1,44 @@
-import * as z from 'zod'
+import * as z from "zod";
 
-import { getColorizedConsoleFormatString } from 'wasp/universal/ansiColors'
-
-const redColorFormatString = getColorizedConsoleFormatString('red');
+import { colorize } from "wasp/universal/ansiColors";
 
 // PRIVATE API (SDK)
-export function ensureEnvSchema<Schema extends z.ZodTypeAny>(
+export function ensureEnvSchema<Schema extends z.ZodType>(
   data: unknown,
-  schema: Schema
+  schema: Schema,
 ): z.infer<Schema> {
-  const result = getValidatedEnvOrError(data, schema)
+  const result = getValidatedEnvOrError(data, schema);
   if (result.success) {
-    return result.data
+    return result.data;
   } else {
-    console.error(`${redColorFormatString}${formatZodEnvErrors(result.error.issues)}`)
-    throw new Error('Error parsing environment variables')
+    console.error(colorize("red", formatZodEnvError(result.error)));
+    throw new Error("Error parsing environment variables");
   }
 }
 
 // PRIVATE API (SDK, Vite config)
-export function getValidatedEnvOrError<Schema extends z.ZodTypeAny>(
+export function getValidatedEnvOrError<Schema extends z.ZodType>(
   env: unknown,
-  schema: Schema
-): z.SafeParseReturnType<unknown, z.infer<Schema>> {
-  return schema.safeParse(env)
+  schema: Schema,
+): z.ZodSafeParseResult<z.infer<Schema>> {
+  return schema.safeParse(env);
 }
 
 // PRIVATE API (SDK, Vite config)
-export function formatZodEnvErrors(issues: z.ZodIssue[]): string {
-  const errorOutput = ['', '══ Env vars validation failed ══', '']
-  for (const error of issues) {
-    errorOutput.push(` - ${error.message}`)
-  }
-  errorOutput.push('')
-  errorOutput.push('════════════════════════════════')
-  return errorOutput.join('\n')
+export function formatZodEnvError(error: z.ZodError): string {
+  const flattenedIssues = z.flattenError(error);
+
+  return [
+    "══ Env vars validation failed ══",
+    "",
+    // Top-level errors
+    ...flattenedIssues.formErrors,
+    "",
+    // Errors per field
+    ...Object.entries(flattenedIssues.fieldErrors).map(
+      ([prop, error]) => `${prop} - ${error}`,
+    ),
+    "",
+    "════════════════════════════════",
+  ].join("\n");
 }

package/data/Generator/templates/sdk/wasp/server/email/core/providers/dummy.ts

@@ -1,34 +1,32 @@
-import { DummyEmailProvider, EmailSender } from "../types";
 import { getDefaultFromField } from "../helpers.js";
+import { DummyEmailProvider, EmailSender } from "../types";
 
-import { getColorizedConsoleFormatString } from 'wasp/universal/ansiColors'
-
-const yellowColorFormatString = getColorizedConsoleFormatString('yellow');
+import { colorize } from "wasp/universal/ansiColors";
 
 // PRIVATE API
 export function initDummyEmailSender(
-    config?: DummyEmailProvider,
+  _config?: DummyEmailProvider,
 ): EmailSender {
-    const defaultFromField = getDefaultFromField();
-    return {
-        send: async (email) => {
-            const fromField = email.from || defaultFromField;
+  const defaultFromField = getDefaultFromField();
+  return {
+    send: async (email) => {
+      const fromField = email.from || defaultFromField;
 
-            console.log(yellowColorFormatString, '╔═══════════════════════╗');
-            console.log(yellowColorFormatString, '║ Dummy email sender ✉️  ║');
-            console.log(yellowColorFormatString, '╚═══════════════════════╝');
-            console.log(`From:    ${fromField.name} <${fromField.email}>`);
-            console.log(`To:      ${email.to}`);
-            console.log(`Subject: ${email.subject}`);
-            console.log(yellowColorFormatString, '═════════ Text ═════════');
-            console.log(email.text);
-            console.log(yellowColorFormatString, '═════════ HTML ═════════');
-            console.log(email.html);
-            console.log(yellowColorFormatString, '════════════════════════');
+      console.log(colorize("yellow", "╔═══════════════════════╗"));
+      console.log(colorize("yellow", "║ Dummy email sender ✉️  ║"));
+      console.log(colorize("yellow", "╚═══════════════════════╝"));
+      console.log(`From:    ${fromField.name} <${fromField.email}>`);
+      console.log(`To:      ${email.to}`);
+      console.log(`Subject: ${email.subject}`);
+      console.log(colorize("yellow", "═════════ Text ═════════"));
+      console.log(email.text);
+      console.log(colorize("yellow", "═════════ HTML ═════════"));
+      console.log(email.html);
+      console.log(colorize("yellow", "════════════════════════"));
 
-            return {
-                success: true,
-            };
-        }
-    }
+      return {
+        success: true,
+      };
+    },
+  };
 }

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

@@ -1,175 +1,180 @@
 {{={= =}=}}
-import * as z from 'zod'
-
-import { ensureEnvSchema } from '../env/validation.js'
+import * as z from "zod"
 
+import { ensureEnvSchema } from "../env/validation.js"
 {=# envValidationSchema.isDefined =}
 {=& envValidationSchema.importStatement =}
-const userServerEnvSchema = {= envValidationSchema.importIdentifier =}
+const userServerEnvSchema = {= envValidationSchema.importIdentifier =};
 {=/ envValidationSchema.isDefined =}
 {=^ envValidationSchema.isDefined =}
-const userServerEnvSchema = z.object({})
+const userServerEnvSchema = z.object({});
 {=/ envValidationSchema.isDefined =}
 
-const waspServerCommonSchema = z.object({
+const waspCommonServerEnvSchema = z.object({
   PORT: z.coerce.number().default({= defaultServerPort =}),
   {= databaseUrlEnvVarName =}: z.string({
-    required_error: '{= databaseUrlEnvVarName =} is required',
+    error: '{= databaseUrlEnvVarName =} is required',
   }),
   PG_BOSS_NEW_OPTIONS: z.string().optional(),
   {=# isEmailSenderEnabled =}
   {=# enabledEmailSenders.isSmtpProviderEnabled =}
   SMTP_HOST: z.string({
-    required_error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_HOST'),
+    error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_HOST'),
   }),
   SMTP_PORT: z.coerce.number({
-    required_error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_PORT'),
-    invalid_type_error: 'SMTP_PORT must be a number',
+    error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_PORT'),
   }),
   SMTP_USERNAME: z.string({
-    required_error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_USERNAME'),
+    error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_USERNAME'),
   }),
   SMTP_PASSWORD: z.string({
-    required_error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_PASSWORD'),
+    error: getRequiredEnvVarErrorMessage('SMTP email sender', 'SMTP_PASSWORD'),
   }),
   {=/ enabledEmailSenders.isSmtpProviderEnabled =}
   {=# enabledEmailSenders.isSendGridProviderEnabled =}
   SENDGRID_API_KEY: z.string({
-    required_error: getRequiredEnvVarErrorMessage('SendGrid email sender', 'SENDGRID_API_KEY'),
+    error: getRequiredEnvVarErrorMessage('SendGrid email sender', 'SENDGRID_API_KEY'),
   }),
   {=/ enabledEmailSenders.isSendGridProviderEnabled =}
   {=# enabledEmailSenders.isMailgunProviderEnabled =}
   MAILGUN_API_KEY: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Mailgun email sender', 'MAILGUN_API_KEY'),
+    error: getRequiredEnvVarErrorMessage('Mailgun email sender', 'MAILGUN_API_KEY'),
   }),
   MAILGUN_DOMAIN: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Mailgun email sender', 'MAILGUN_DOMAIN'),
+    error: getRequiredEnvVarErrorMessage('Mailgun email sender', 'MAILGUN_DOMAIN'),
   }),
   MAILGUN_API_URL: z.string().optional(),
   {=/ enabledEmailSenders.isMailgunProviderEnabled =}
   {=/ isEmailSenderEnabled =}
   SKIP_EMAIL_VERIFICATION_IN_DEV: z
     .enum(['true', 'false'], {
-      message: 'SKIP_EMAIL_VERIFICATION_IN_DEV must be either "true" or "false"',
+      error: 'SKIP_EMAIL_VERIFICATION_IN_DEV must be either "true" or "false"',
     })
-    .transform((value) => value === 'true')
-    .default('false'),
+    .default('false')
+    .transform((value) => value === 'true'),
   {=# isAuthEnabled =}
   {=# enabledAuthProviders.isGoogleAuthEnabled =}
   GOOGLE_CLIENT_ID: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Google auth provider', 'GOOGLE_CLIENT_ID'),
+    error: getRequiredEnvVarErrorMessage('Google auth provider', 'GOOGLE_CLIENT_ID'),
   }),
   GOOGLE_CLIENT_SECRET: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Google auth provider', 'GOOGLE_CLIENT_SECRET'),
+    error: getRequiredEnvVarErrorMessage('Google auth provider', 'GOOGLE_CLIENT_SECRET'),
   }),
   {=/ enabledAuthProviders.isGoogleAuthEnabled =}
   {=# enabledAuthProviders.isGitHubAuthEnabled =}
   GITHUB_CLIENT_ID: z.string({
-    required_error: getRequiredEnvVarErrorMessage('GitHub auth provider', 'GITHUB_CLIENT_ID'),
+    error: getRequiredEnvVarErrorMessage('GitHub auth provider', 'GITHUB_CLIENT_ID'),
   }),
   GITHUB_CLIENT_SECRET: z.string({
-    required_error: getRequiredEnvVarErrorMessage('GitHub auth provider', 'GITHUB_CLIENT_SECRET'),
+    error: getRequiredEnvVarErrorMessage('GitHub auth provider', 'GITHUB_CLIENT_SECRET'),
   }),
   {=/ enabledAuthProviders.isGitHubAuthEnabled =}
   {=# enabledAuthProviders.isSlackAuthEnabled =}
   SLACK_CLIENT_ID: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Slack auth provider', 'SLACK_CLIENT_ID'),
+    error: getRequiredEnvVarErrorMessage('Slack auth provider', 'SLACK_CLIENT_ID'),
   }),
   SLACK_CLIENT_SECRET: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Slack auth provider', 'SLACK_CLIENT_SECRET'),
+    error: getRequiredEnvVarErrorMessage('Slack auth provider', 'SLACK_CLIENT_SECRET'),
   }),
   {=/ enabledAuthProviders.isSlackAuthEnabled =}
   {=# enabledAuthProviders.isDiscordAuthEnabled =}
   DISCORD_CLIENT_ID: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Discord auth provider', 'DISCORD_CLIENT_ID'),
+    error: getRequiredEnvVarErrorMessage('Discord auth provider', 'DISCORD_CLIENT_ID'),
   }),
   DISCORD_CLIENT_SECRET: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Discord auth provider', 'DISCORD_CLIENT_SECRET'),
+    error: getRequiredEnvVarErrorMessage('Discord auth provider', 'DISCORD_CLIENT_SECRET'),
   }),
   {=/ enabledAuthProviders.isDiscordAuthEnabled =}
   {=# enabledAuthProviders.isKeycloakAuthEnabled =}
   KEYCLOAK_CLIENT_ID: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Keycloak auth provider', 'KEYCLOAK_CLIENT_ID'),
+    error: getRequiredEnvVarErrorMessage('Keycloak auth provider', 'KEYCLOAK_CLIENT_ID'),
   }),
   KEYCLOAK_CLIENT_SECRET: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Keycloak auth provider', 'KEYCLOAK_CLIENT_SECRET'),
+    error: getRequiredEnvVarErrorMessage('Keycloak auth provider', 'KEYCLOAK_CLIENT_SECRET'),
   }),
-  KEYCLOAK_REALM_URL: z
-    .string({
-      required_error: getRequiredEnvVarErrorMessage('Keycloak auth provider', 'KEYCLOAK_REALM_URL'),
+  KEYCLOAK_REALM_URL:
+    z.string({
+      error: getRequiredEnvVarErrorMessage('Keycloak auth provider', 'KEYCLOAK_REALM_URL'),
     })
-    .url({
-      message: 'KEYCLOAK_REALM_URL must be a valid URL',
-    }),
+    .pipe(
+      z.url({
+        error: 'KEYCLOAK_REALM_URL must be a valid URL',
+      })
+    ),
   {=/ enabledAuthProviders.isKeycloakAuthEnabled =}
   {=# enabledAuthProviders.isMicrosoftAuthEnabled =}
   MICROSOFT_TENANT_ID: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Microsoft auth provider', 'MICROSOFT_TENANT_ID'),
+    error: getRequiredEnvVarErrorMessage('Microsoft auth provider', 'MICROSOFT_TENANT_ID'),
   }),
   MICROSOFT_CLIENT_ID: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Microsoft auth provider', 'MICROSOFT_CLIENT_ID'),
+    error: getRequiredEnvVarErrorMessage('Microsoft auth provider', 'MICROSOFT_CLIENT_ID'),
   }),
   MICROSOFT_CLIENT_SECRET: z.string({
-    required_error: getRequiredEnvVarErrorMessage('Microsoft auth provider', 'MICROSOFT_CLIENT_SECRET'),
+    error: getRequiredEnvVarErrorMessage('Microsoft auth provider', 'MICROSOFT_CLIENT_SECRET'),
   }),
   {=/ enabledAuthProviders.isMicrosoftAuthEnabled =}
   {=/ isAuthEnabled =}
-})
+});
 
-const serverUrlSchema = z
-  .string({
-    required_error: '{= serverUrlEnvVarName =} is required',
-  })
-  .url({
-    message: '{= serverUrlEnvVarName =} must be a valid URL',
+const serverUrlSchema =
+  z.string({
+    error: '{= serverUrlEnvVarName =} is required',
   })
+  .pipe(
+    z.url({
+      error: '{= serverUrlEnvVarName =} must be a valid URL',
+    })
+  )
 
-const clientUrlSchema = z
-  .string({
-    required_error: '{= clientUrlEnvVarName =} is required',
-  })
-  .url({
-    message: '{= clientUrlEnvVarName =} must be a valid URL',
+const clientUrlSchema =
+  z.string({
+    error: '{= clientUrlEnvVarName =} is required',
   })
+  .pipe(
+    z.url({
+      error: '{= clientUrlEnvVarName =} must be a valid URL',
+    })
+  )
 
 {=# isAuthEnabled =}
 const jwtTokenSchema = z
   .string({
-    required_error: '{= jwtSecretEnvVarName =} is required',
+    error: '{= jwtSecretEnvVarName =} is required',
   })
 {=/ isAuthEnabled =}
 
 // In development, we provide default values for some environment variables
 // to make the development process easier.
-const serverDevSchema = z.object({
-  NODE_ENV: z.literal('development'),
+const waspDevServerEnvSchema = z.object({
+  NODE_ENV: z.literal("development"),
   "{= serverUrlEnvVarName =}": serverUrlSchema
-    .default('{= defaultServerUrl =}'),
+    .default("{= defaultServerUrl =}"),
   "{= clientUrlEnvVarName =}": clientUrlSchema
-    .default('{= defaultClientUrl =}'),
+    .default("{= defaultClientUrl =}"),
   {=# isAuthEnabled =}
   "{= jwtSecretEnvVarName =}": jwtTokenSchema
-    .default('DEVJWTSECRET'),
+    .default("DEVJWTSECRET"),
   {=/ isAuthEnabled =}
-})
+});
 
-const serverProdSchema = z.object({
-  NODE_ENV: z.literal('production'),
+const waspProdServerEnvSchema = z.object({
+  NODE_ENV: z.literal("production"),
   "{= serverUrlEnvVarName =}": serverUrlSchema,
   "{= clientUrlEnvVarName =}": clientUrlSchema,
   {=# isAuthEnabled =}
   "{= jwtSecretEnvVarName =}": jwtTokenSchema,
   {=/ isAuthEnabled =}
-})
+});
 
-const serverCommonSchema = userServerEnvSchema.merge(waspServerCommonSchema)
-const serverEnvSchema = z.discriminatedUnion('NODE_ENV', [
-  serverDevSchema.merge(serverCommonSchema),
-  serverProdSchema.merge(serverCommonSchema)
-])
+const waspServerEnvSchema = z.discriminatedUnion("NODE_ENV", [
+  z.object({...waspCommonServerEnvSchema.shape, ...waspDevServerEnvSchema.shape}),
+  z.object({...waspCommonServerEnvSchema.shape, ...waspProdServerEnvSchema.shape}),
+]);
+const serverEnvSchema = userServerEnvSchema.and(waspServerEnvSchema);
 
-const defaultNodeEnvValue = serverDevSchema.shape.NODE_ENV.value;
+const defaultNodeEnvValue = waspDevServerEnvSchema.shape.NODE_ENV.value;
 const { NODE_ENV: inputNodeEnvValue, ...restEnv } = process.env;
+
 // PUBLIC API
 export const env = ensureEnvSchema(
   {
@@ -177,7 +182,7 @@ export const env = ensureEnvSchema(
     ...restEnv,
   },
   serverEnvSchema,
-)
+);
 
 function getRequiredEnvVarErrorMessage(featureName: string, envVarName: string) {
   return `${envVarName} is required when using ${featureName}`

package/data/Generator/templates/sdk/wasp/universal/ansiColors.ts

@@ -1,14 +1,58 @@
-export const colors = {
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-} as const;
+// PRIVATE API (SDK, client)
+/**
+ * Wraps each line of text with ANSI color codes.
+ * Only works in Node.js (server-side), not in the browser.
+ *
+ * Each line is individually wrapped because Wasp reads child process
+ * output line-by-line and re-prints it with a prefix (e.g. `[ Server ]`).
+ * A single color code spanning multiple lines would only color the first line.
+ *
+ * @example
+ * ```typescript
+ * console.log(colorize('red', 'This is red text'));
+ * ```
+ *
+ * @internal This is a private API for: SDK, client.
+ */
+export function colorize(
+  color: keyof typeof ansiColorCodes,
+  text: string,
+): string {
+  if (!supportsAnsiFormatting()) {
+    return text;
+  }
 
-export const resetColor = "\x1b[0m";
+  const ansiColorCode = ansiColorCodes[color];
+  return text
+    .split("\n")
+    .map((line) => `${ansiColorCode}${line}${ansiResetCode}`)
+    .join("\n");
+}
 
-// PRIVATE API (SDK, client)
-// Used with console.log() to colorize the output
-// Example: console.log(getColorizedConsoleFormatString('red'), 'This is red text');
-export function getColorizedConsoleFormatString(colorKey: keyof typeof colors): string {
-  const color = colors[colorKey];
-  return `${color}%s${resetColor}`;
+function supportsAnsiFormatting(): boolean {
+  const isBrowser = !!globalThis.window;
+  const isNode = !!globalThis.process;
+
+  if (isBrowser && "chrome" in window) {
+    return true;
+  }
+  if (isNode) {
+    if ("NO_COLOR" in process.env) {
+      return false;
+    }
+    // Wasp runs the server as a child process with piped stdout/stderr,
+    // so streams are not TTYs and hasColors() won't exist on them.
+    // We default to true for non-browser runtimes because Wasp's CLI
+    // handles the final terminal output and supports ANSI codes.
+    return true;
+  }
+
+  return false;
 }
+
+const ansiColorCodes = {
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+} as const;
+
+const ansiResetCode = "\x1b[0m";

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

@@ -66,9 +66,6 @@ async function regionExists(regionCode) {
 export async function secretExists(secretName) {
     const proc = await $ `flyctl secrets list -j`;
     const secrets = FlySecretListSchema.parse(proc.json());
-    return secrets.some((s) => {
-        const name = "name" in s ? s.name : s.Name;
-        return name === secretName;
-    });
+    return secrets.some((s) => s.name === secretName);
 }
 //# sourceMappingURL=flyCli.js.map

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

@@ -26,9 +26,13 @@ export const FlyRegionListSchema = z.union([
 ]);
 export const FlySecretListSchema = z.union([
     // current version
-    z.array(z.object({
+    z.array(z
+        .object({
         Name: z.string(),
-    })),
+    })
+        .transform((data) => ({
+        name: data.Name,
+    }))),
     // not the output yet, but just in case they update the command in the future
     z.array(z.object({
         name: z.string(),

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

@@ -42,11 +42,17 @@ export function getAppNameFromToml(path) {
 }
 export function getInferredBasenameFromServerToml(paths) {
     const serverFlyAppName = getAppNameFromToml(paths.serverTomlPath);
-    return serverFlyAppName.replace("-server", "");
+    return inferServerBasename(serverFlyAppName);
 }
 export function getInferredBasenameFromClientToml(paths) {
     const clientFlyAppName = getAppNameFromToml(paths.clientTomlPath);
-    return clientFlyAppName.replace("-client", "");
+    return inferClientBasename(clientFlyAppName);
+}
+export function inferServerBasename(name) {
+    return name.replace(/-server$/, "");
+}
+export function inferClientBasename(name) {
+    return name.replace(/-client$/, "");
 }
 export function replaceLineInLocalToml(searchValue, replaceValue) {
     const content = fs.readFileSync("fly.toml", "utf8");

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

@@ -5,6 +5,7 @@ import { ensureWaspProjectIsBuilt } from "../../../../common/waspBuild.js";
 import { getClientDeploymentDir, getServerDeploymentDir, } from "../../../../common/waspProject.js";
 import { createCommandWithCwd } from "../../../../common/zx.js";
 import { createDeploymentInstructions, } from "../../DeploymentInstructions.js";
+import { getRailwayEnvVarValueReference } from "../../env.js";
 import { clientAppPort, serverAppPort } from "../../ports.js";
 import { initRailwayProject, linkRailwayProjectToWaspProjectDir, } from "../../railwayProject/cli.js";
 import { getRailwayProjectStatus, ProjectStatus, } from "../../railwayProject/index.js";
@@ -142,16 +143,4 @@ async function setupClient({ cmdOptions: options, clientServiceName, }) {
     ].flat());
     waspSays("Client setup complete!");
 }
-function getRailwayEnvVarValueReference(name, { serviceName } = {}) {
-    // Railway variable references have the format ${{VARIABLE}} for local variables
-    // or ${{serviceName.VARIABLE}} for cross-service references.
-    // When the service name contains special characters (like hyphens with numbers),
-    // Railway requires it to be quoted: ${{"service-name".VARIABLE}}
-    const parts = [name];
-    if (serviceName) {
-        // JSON.stringify wraps the string in quotes and escapes any special characters.
-        parts.unshift(JSON.stringify(serviceName));
-    }
-    return "${{" + parts.join(".") + "}}";
-}
 //# sourceMappingURL=setup.js.map

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

@@ -0,0 +1,13 @@
+export function getRailwayEnvVarValueReference(name, { serviceName } = {}) {
+    // Railway variable references have the format ${{VARIABLE}} for local variables
+    // or ${{serviceName.VARIABLE}} for cross-service references.
+    // When the service name contains special characters (like hyphens with numbers),
+    // Railway requires it to be quoted: ${{"service-name".VARIABLE}}
+    const parts = [name];
+    if (serviceName) {
+        // JSON.stringify handles quoting for service names with special characters.
+        parts.unshift(JSON.stringify(serviceName));
+    }
+    return "${{" + parts.join(".") + "}}";
+}
+//# sourceMappingURL=env.js.map

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

@@ -29,7 +29,7 @@ export async function generateServiceUrl(serviceName, port, options) {
         return domain;
     }
 }
-function extractServiceUrlFromString(text) {
+export function extractServiceUrlFromString(text) {
     const match = text.match(/https:\/\/[^\s]*/);
     if (match === null) {
         throw new Error("Failed to get service domain");