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

package/data/Generator/templates/server/src/views/wrong-port.ts

@@ -0,0 +1,123 @@
+/*
+  This template gets rendered when you visit the root route on the server (i.e.
+  http://localhost:3001/) in development mode.
+
+  Some of the data passed to this template is known at runtime and not compile
+  time, so we need to craft the string at runtime with a JS template string. We
+  explicitly do not use Wasp mustaches here so we don't have to reason about two
+  different templating systems.
+
+  For now, we don't serve any other static files in our routes, so all the
+  resources needed (CSS, images, etc.) must be inlined into the file.
+*/
+
+// The /* HTML */ comment is a hint to `prettier` to format this string as HTML.
+export const makeWrongPortPage = ({
+  appName,
+  frontendUrl,
+}: {
+  appName: string;
+  frontendUrl: string;
+}): string => /* HTML */ `
+  <!doctype html>
+  <html lang="en">
+    <head>
+      <meta charset="UTF-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+      <title>${appName} API Server</title>
+
+      <style>
+        :root {
+          --page-background: #f0f0f0;
+          --wrapper-background: white;
+          --wasp-yellow: #f5cc05;
+          --main-link-color: #1a73e8;
+        }
+
+        .wrapper {
+          font-family: system-ui, sans-serif;
+          width: 90%;
+          max-width: 600px;
+          margin: 2em auto;
+        }
+
+        h1,
+        h2 {
+          margin: 0;
+        }
+
+        .main-link {
+          text-align: center;
+          font-size: 1.5em;
+          font-weight: bold;
+          font-family: ui-monospace, monospace;
+        }
+
+        .icon {
+          width: 1em;
+          height: 1em;
+        }
+
+        .wasp-title {
+          margin: 0.5em 0;
+          display: flex;
+          align-items: center;
+          gap: 0.2em;
+        }
+
+        body {
+          background-color: var(--page-background);
+        }
+
+        main {
+          background-color: var(--wrapper-background);
+          padding: 1.5em;
+          border-radius: 10px;
+        }
+
+        a,
+        a:visited {
+          color: var(--main-link-color);
+        }
+      </style>
+    </head>
+    <body>
+      <div class="wrapper">
+        <header>
+          <h2 class="wasp-title">
+            <svg viewBox="0 0 161 161" class="icon" alt="Wasp Logo">
+              <circle cx="80.5" cy="80.5" r="79" fill="var(--wasp-yellow)" />
+              <path
+                d="M88.67 114.33h2.91q6 0 7.87-1.89c1.22-1.25 1.83-3.9 1.83-7.93V93.89c0-4.46.65-7.7 1.93-9.73s3.51-3.43 6.67-4.2q-4.69-1.08-6.65-4.12c-1.3-2-2-5.28-2-9.77V55.44q0-6-1.83-7.93t-7.87-1.88h-2.86V39.5h2.65q10.65 0 14.24 3.15t3.59 12.62v10.29c0 4.28.77 7.24 2.29 8.87s4.3 2.44 8.32 2.44h2.74V83h-2.74q-6 0-8.32 2.49c-1.52 1.65-2.29 4.64-2.29 9v10.25q0 9.47-3.59 12.64t-14.24 3.12h-2.65Z"
+              />
+              <path d="M38.5 85.15h37.33v7.58H38.5Zm0-17.88h37.33v7.49H38.5Z" />
+            </svg>
+            Wasp
+          </h2>
+        </header>
+
+        <main>
+          <h1>${appName} API Server</h1>
+          <p>
+            The server is up and running. This is the backend part of your Wasp
+            application.
+          </p>
+          <p>
+            If you want to visit your frontend application, go to this URL in
+            your browser:
+          </p>
+          <a href="${frontendUrl}" class="main-link">
+            <p>${frontendUrl}</p>
+          </a>
+          <p>
+            <small>
+              This message is shown because you are running the server in
+              development mode. In production, this route would not show
+              anything.
+            </small>
+          </p>
+        </main>
+      </div>
+    </body>
+  </html>
+`;

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

@@ -0,0 +1,59 @@
+{{={= =}=}}
+
+import http from 'http'
+import { Server, Socket } from 'socket.io'
+import type { ServerType } from 'wasp/server/webSocket'
+
+import { config, prisma } from 'wasp/server'
+
+{=# isAuthEnabled =}
+import { getSessionAndUserFromSessionId } from 'wasp/auth/session'
+import { makeAuthUserIfPossible } from 'wasp/auth/user'
+{=/ isAuthEnabled =}
+
+{=& userWebSocketFn.importStatement =}
+
+// Initializes the WebSocket server and invokes the user's WebSocket function.
+export async function init(server: http.Server): Promise<void> {
+  // TODO: In the future, we can consider allowing a clustering option.
+  // Ref: https://github.com/wasp-lang/wasp/issues/1228
+
+  // TODO: Uncomment the type annotation once we make sure that the types between different packages are aligned.
+  // Ref: https://github.com/wasp-lang/wasp/issues/2726
+  const io /* : ServerType */ = new Server(server, {
+    cors: {
+      origin: config.frontendUrl,
+    }
+  })
+
+  {=# isAuthEnabled =}
+  io.use(addUserToSocketDataIfAuthenticated)
+  {=/ isAuthEnabled =}
+
+  const context = {
+    entities: {
+      {=# allEntities =}
+      {= name =}: prisma.{= prismaIdentifier =},
+      {=/ allEntities =}
+    }
+  }
+
+  await ({= userWebSocketFn.importIdentifier =} as any)(io, context)
+}
+
+{=# isAuthEnabled =}
+async function addUserToSocketDataIfAuthenticated(socket: Socket, next: (err?: Error) => void) {
+  const sessionId = socket.handshake.auth.sessionId
+  if (sessionId) {
+    try {
+      const sessionAndUser = await getSessionAndUserFromSessionId(sessionId)
+      const user = sessionAndUser ? makeAuthUserIfPossible(sessionAndUser.user) : null
+      socket.data = {
+        ...socket.data,
+        user,
+      }
+    } catch (err) { }
+  }
+  next()
+}
+{=/ isAuthEnabled =}

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

@@ -0,0 +1,41 @@
+{{={= =}=}}
+{
+  "extends": "@tsconfig/node{= majorNodeVersion =}/tsconfig.json",
+  "compilerOptions": {
+    // Overriding this until we implement more complete TypeScript support.
+    "strict": false,
+    "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
+    "rootDir": ".",
+    // Enable source map for debugging
+    "sourceMap": true,
+    // We are using rollup and extensionless imports, our module and module
+    // resolution reflect that.
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    // The remaining settings should match the extended nodeXY/tsconfig.json, but I kept
+    // them here to be explicit.
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "target": "es2022",
+    "lib" : ["es2023"]
+  },
+  "include": [
+    "src"
+  ],
+  "references": [
+    { "path": "{= srcTsConfigPath =}" }
+  ]
+}

package/data/Lsp/templates/ts/action.fn.ts

@@ -0,0 +1,12 @@
+import { type {{upperDeclName}} } from 'wasp/server/operations'
+
+type {{upperDeclName}}Input = void
+type {{upperDeclName}}Output = void
+
+{{#named?}}export {{/named?}}const {{name}}: {{upperDeclName}}<{{upperDeclName}}Input, {{upperDeclName}}Output> = async (args, context) => {
+  // Implementation goes here
+}
+
+{{#default?}}
+export default {{name}}
+{{/default?}}

package/data/Lsp/templates/ts/operation.fn.js

@@ -0,0 +1,7 @@
+{{#named?}}export {{/named?}}const {{name}} = async (args, context) => {
+  // Implementation goes here
+}
+
+{{#default?}}
+export default {{name}}
+{{/default?}}

package/data/Lsp/templates/ts/page.component.jsx

@@ -0,0 +1,9 @@
+{{#named?}}export {{/named?}}function {{name}}() {
+  return (
+    <div>Hello world!</div>
+  )
+}
+
+{{#default?}}
+export default {{name}}
+{{/default?}}

package/data/Lsp/templates/ts/query.fn.ts

@@ -0,0 +1,12 @@
+import { type {{upperDeclName}} } from 'wasp/server/operations'
+
+type {{upperDeclName}}Input = void
+type {{upperDeclName}}Output = void
+
+{{#named?}}export {{/named?}}const {{name}}: {{upperDeclName}}<{{upperDeclName}}Input, {{upperDeclName}}Output> = async (args, context) => {
+  // Implementation goes here
+}
+
+{{#default?}}
+export default {{name}}
+{{/default?}}

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

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

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

@@ -0,0 +1,26 @@
+import { waspSays } from "./terminal.js";
+import { getClientBuildArtefactsDir, getClientBuildDir, } from "./waspProject.js";
+import { createCommandWithCwd } from "./zx.js";
+export const serverUrlEnvVarName = "REACT_APP_API_URL";
+export async function buildClient(defaultServerAppUrl, { waspProjectDir }) {
+    waspSays("Building web client for production...");
+    waspSays(`If you configured a custom domain for the server, you should run the command with an env variable: ${serverUrlEnvVarName}=https://serverUrl.com <command>`);
+    const clientBuildDir = getClientBuildDir(waspProjectDir);
+    const npmCli = createCommandWithCwd("npm", clientBuildDir);
+    await npmCli(["install"]);
+    const serverUrl = getServerAppUrlEnvValue() ?? defaultServerAppUrl;
+    await npmCli(["run", "build"], {
+        env: {
+            ...process.env,
+            [serverUrlEnvVarName]: serverUrl,
+        },
+    });
+    return getClientBuildArtefactsDir(waspProjectDir);
+}
+// We allow users to specify the server URL that the client will connect to
+// using an environment variable.
+// TODO: improve this API to allow specifying the server URL via options or a config file.
+function getServerAppUrlEnvValue() {
+    return process.env[serverUrlEnvVarName];
+}
+//# sourceMappingURL=clientApp.js.map

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

@@ -0,0 +1,8 @@
+export function getFullCommandName(command) {
+    const fullCommandNameParts = [command.name()];
+    for (let parent = command.parent; parent; parent = parent.parent) {
+        fullCommandNameParts.unshift(parent.name());
+    }
+    return fullCommandNameParts.join(" ");
+}
+//# sourceMappingURL=commander.js.map

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

@@ -0,0 +1,5 @@
+import crypto from "crypto";
+export function generateRandomHexString(sizeBytes = 32) {
+    return crypto.randomBytes(sizeBytes).toString("hex");
+}
+//# sourceMappingURL=random.js.map

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

@@ -0,0 +1,24 @@
+import { chalk } from "zx";
+export function waspSays(str) {
+    const formattedStr = str
+        .split("\n")
+        .map((line) => `🚀 ${line}`)
+        .join("\n");
+    console.log(chalk.yellow(formattedStr));
+}
+export function displayWaspRocketImage() {
+    // Escaping backslashes makes it look weird here, but it works in console.
+    const asciiArt = `
+
+                    __
+                   // \\
+                   \\\\_/ //
+             _    -(||)(')
+            \\ \\____///_____
+   #########[==__DEPLOYED__}
+            /_/
+
+  `;
+    console.log(asciiArt);
+}
+//# sourceMappingURL=terminal.js.map

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

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

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

@@ -0,0 +1,14 @@
+import fs from "fs";
+import path from "node:path";
+export function assertDirPathIsAbsolute(dirPath, dirNameInError) {
+    if (!path.isAbsolute(dirPath)) {
+        throw new Error(`The ${dirNameInError} path must be absolute.`);
+    }
+}
+export function assertDirExists(dirPath, dirNameInError) {
+    const dirExists = fs.existsSync(dirPath);
+    if (!dirExists) {
+        throw new Error(`The ${dirNameInError} does not exist.`);
+    }
+}
+//# sourceMappingURL=validation.js.map

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

@@ -0,0 +1,21 @@
+import { waspSays } from "./terminal.js";
+import { createCommandWithCwd } from "./zx.js";
+export const ensureWaspProjectIsBuilt = createEnsureWaspProjectIsBuilt();
+function createEnsureWaspProjectIsBuilt() {
+    async function buildWaspApp({ waspProjectDir, waspExe, }) {
+        waspSays("Building your Wasp app...");
+        const waspCli = createCommandWithCwd(waspExe, waspProjectDir);
+        return waspCli(["build"]);
+    }
+    // We want to build the Wasp project only once per CLI invocation.
+    // Sometimes `ensureWaspProjectIsBuilt` is called multiple times
+    // (e.g. in `setup` command, we call it and then again when deploying).
+    let cachedWaspBuildResult = undefined;
+    return (...params) => {
+        if (cachedWaspBuildResult === undefined) {
+            cachedWaspBuildResult = buildWaspApp(...params);
+        }
+        return cachedWaspBuildResult;
+    };
+}
+//# sourceMappingURL=waspBuild.js.map

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

@@ -0,0 +1,43 @@
+import fs from "fs";
+import path from "node:path";
+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"], {
+        quiet: true,
+        nothrow: true,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error([
+            "The supplied Wasp directory does not appear to be a valid Wasp project.",
+            "Please double check your Wasp project directory.",
+        ].join("\n"));
+    }
+}
+export function assertWaspProjectDirIsAbsoluteAndPresent(waspProjectDir) {
+    const dirNameInError = "Wasp project directory";
+    assertDirPathIsAbsolute(waspProjectDir, dirNameInError);
+    assertDirExists(waspProjectDir, dirNameInError);
+}
+export function buildDirExists(waspProjectDir) {
+    return fs.existsSync(getWaspBuildDir(waspProjectDir));
+}
+export function getServerBuildArtefactsDir(waspProjectDir) {
+    return getServerBuildDir(waspProjectDir);
+}
+export function getClientBuildArtefactsDir(waspProjectDir) {
+    const clientBuildDir = getClientBuildDir(waspProjectDir);
+    return path.join(clientBuildDir, "build");
+}
+function getWaspBuildDir(waspProjectDir) {
+    return path.join(waspProjectDir, ".wasp", "build");
+}
+export function getServerBuildDir(waspProjectDir) {
+    // The server is built from the Wasp build directory.
+    return path.join(getWaspBuildDir(waspProjectDir), ".");
+}
+export function getClientBuildDir(waspProjectDir) {
+    return path.join(getWaspBuildDir(waspProjectDir), "web-app");
+}
+//# sourceMappingURL=waspProject.js.map

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

@@ -0,0 +1,10 @@
+import { $ } from "zx";
+export function createCommandWithCwd(command, cwd) {
+    return (commandArgs, options) => {
+        return $({
+            cwd,
+            ...(options ?? {}),
+        }) `${command} ${commandArgs}`;
+    };
+}
+//# sourceMappingURL=zx.js.map

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

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { $, syncProcessCwd } from "zx";
+import { waspSays } from "./common/terminal.js";
+import { createFlyCommand } from "./providers/fly/index.js";
+import { createRailwayCommand } from "./providers/railway/index.js";
+const program = new Command();
+program
+    .name("wasp deploy")
+    .description("CLI for deploying Wasp apps to various clouds")
+    .allowUnknownOption();
+// We want to see the output of commands by default
+$.verbose = true;
+// Keeps the process.cwd() in sync with the internal $ current working directory
+// if it is changed via cd().
+syncProcessCwd();
+program.addCommand(createFlyCommand());
+program.addCommand(createRailwayCommand());
+try {
+    // parseAsync not only parses the command line arguments but also
+    // executes the command and it will throw an error if the command fails.
+    await program.parseAsync();
+}
+catch (error) {
+    if (error instanceof Error && error.message) {
+        waspSays(error.message);
+    }
+    process.exit(1);
+}
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,36 @@
+import { cd } from "zx";
+import { getClientBuildDir, getServerBuildDir, } from "../../common/waspProject.js";
+import { clientTomlExistsInProject, copyLocalClientTomlToProject, copyLocalServerTomlToProject, copyProjectClientTomlLocally, copyProjectServerTomlLocally, serverTomlExistsInProject, } from "./tomlFile.js";
+export var ContextOption;
+(function (ContextOption) {
+    ContextOption["Client"] = "client";
+    ContextOption["Server"] = "server";
+})(ContextOption || (ContextOption = {}));
+export function getCommonOps(context, waspProjectDir, paths) {
+    const commonOps = {
+        [ContextOption.Client]: createClientCommonOps(waspProjectDir, paths),
+        [ContextOption.Server]: createServerCommonOps(waspProjectDir, paths),
+    };
+    return commonOps[context];
+}
+function createClientCommonOps(waspProjectDir, paths) {
+    return {
+        waspProjectDir,
+        paths,
+        cdToBuildDir: () => cd(getClientBuildDir(waspProjectDir)),
+        tomlExistsInProject: () => clientTomlExistsInProject(paths),
+        copyLocalTomlToProject: () => copyLocalClientTomlToProject(paths),
+        copyProjectTomlLocally: () => copyProjectClientTomlLocally(paths),
+    };
+}
+function createServerCommonOps(waspProjectDir, paths) {
+    return {
+        waspProjectDir,
+        paths,
+        cdToBuildDir: () => cd(getServerBuildDir(waspProjectDir)),
+        tomlExistsInProject: () => serverTomlExistsInProject(paths),
+        copyLocalTomlToProject: () => copyLocalServerTomlToProject(paths),
+        copyProjectTomlLocally: () => copyProjectServerTomlLocally(paths),
+    };
+}
+//# sourceMappingURL=CommonOps.js.map

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

@@ -0,0 +1,12 @@
+export function createDeploymentInstructions({ baseName, cmdOptions, tomlFilePaths, region, }) {
+    return Object.freeze({
+        baseName,
+        region,
+        cmdOptions,
+        tomlFilePaths,
+        clientFlyAppName: `${baseName}-client`,
+        serverFlyAppName: `${baseName}-server`,
+        dbName: `${baseName}-db`,
+    });
+}
+//# sourceMappingURL=DeploymentInstructions.js.map

package/data/packages/deploy/dist/providers/fly/commands/cmd/CmdCmdOptions.js

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

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

@@ -0,0 +1,29 @@
+import { $ } from "zx";
+import { waspSays } from "../../../../common/terminal.js";
+import { ensureWaspProjectIsBuilt } from "../../../../common/waspBuild.js";
+import { getCommonOps } from "../../CommonOps.js";
+import { deleteLocalToml, getTomlFilePaths, localTomlExists, } from "../../tomlFile.js";
+// Runs a command by copying down the project toml files, executing it, and copying it back up (just in case).
+// If the toml file does not exist, some commands will not run with additional args (e.g. -a <appname>).
+export async function cmd(flyctlArgs, cmdOptions) {
+    if (cmdOptions.org) {
+        flyctlArgs.push("--org", cmdOptions.org);
+    }
+    waspSays(`Running ${cmdOptions.context} command: flyctl ${flyctlArgs.join(" ")}`);
+    await ensureWaspProjectIsBuilt(cmdOptions);
+    const tomlFilePaths = getTomlFilePaths(cmdOptions);
+    const commonOps = getCommonOps(cmdOptions.context, cmdOptions.waspProjectDir, tomlFilePaths);
+    await runFlyctlCommand(commonOps, flyctlArgs);
+}
+async function runFlyctlCommand(commonOps, flyctlArgs) {
+    commonOps.cdToBuildDir();
+    deleteLocalToml();
+    if (commonOps.tomlExistsInProject()) {
+        commonOps.copyProjectTomlLocally();
+    }
+    await $ `flyctl ${flyctlArgs}`;
+    if (localTomlExists()) {
+        commonOps.copyLocalTomlToProject();
+    }
+}
+//# sourceMappingURL=cmd.js.map

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

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

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

@@ -0,0 +1,55 @@
+import { $, ProcessOutput, question } from "zx";
+import { getFullCommandName } from "../../../../common/commander.js";
+import { waspSays } from "../../../../common/terminal.js";
+import { createDeploymentInstructions } from "../../DeploymentInstructions.js";
+import { flyDeployCommand, flySetupCommand } from "../../index.js";
+import { getInferredBasenameFromServerToml, getTomlFilePaths, serverTomlExistsInProject, } from "../../tomlFile.js";
+export async function createDb(region, cmdOptions) {
+    waspSays("Creating your DB on Fly.io!");
+    const tomlFilePaths = getTomlFilePaths(cmdOptions);
+    if (!serverTomlExistsInProject(tomlFilePaths)) {
+        throw new Error(`${tomlFilePaths.serverTomlPath} missing. Skipping DB creation. Perhaps you need to run "${getFullCommandName(flySetupCommand)}" first?`);
+    }
+    const inferredBaseName = getInferredBasenameFromServerToml(tomlFilePaths);
+    const deploymentInstructions = createDeploymentInstructions({
+        baseName: inferredBaseName,
+        region,
+        cmdOptions,
+        tomlFilePaths,
+    });
+    // Creates a DB, waits for it to come up, then links it to the app.
+    // The attachment process shares the DATABASE_URL secret.
+    const createArgs = [
+        "--name",
+        deploymentInstructions.dbName,
+        "--region",
+        deploymentInstructions.region,
+        "--vm-size",
+        cmdOptions.vmSize,
+        "--initial-cluster-size",
+        cmdOptions.initialClusterSize,
+        "--volume-size",
+        cmdOptions.volumeSize,
+    ];
+    if (cmdOptions.dbImage) {
+        createArgs.push("--image-ref", cmdOptions.dbImage);
+    }
+    if (deploymentInstructions.cmdOptions.org) {
+        createArgs.push("--org", deploymentInstructions.cmdOptions.org);
+    }
+    try {
+        await $ `flyctl postgres create ${createArgs}`;
+        await $ `flyctl postgres attach ${deploymentInstructions.dbName} -a ${deploymentInstructions.serverFlyAppName}`;
+    }
+    catch (error) {
+        if (error instanceof ProcessOutput) {
+            throw new Error(error.stderr.trim());
+        }
+        else {
+            throw error;
+        }
+    }
+    await question("Please take note of your database credentials above, as they will not be available in plaintext again. Press any key to continue.");
+    waspSays(`Don't forget to deploy your app by running "${getFullCommandName(flyDeployCommand)}".`);
+}
+//# sourceMappingURL=createDb.js.map

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

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