@gadgetinc/ggt 0.4.10 → 1.0.0

package/lib/commands/deploy.js

@@ -1,271 +1,369 @@
-import chalk from "chalk";
-import ora from "ora";
-import { REMOTE_SERVER_CONTRACT_STATUS_SUBSCRIPTION } from "../services/app/edit/operation.js";
-import { FileSync, FileSyncArgs } from "../services/filesync/filesync.js";
-import { select } from "../services/output/prompt.js";
+import assert from "node:assert";
+import terminalLink from "terminal-link";
+import { PUBLISH_STATUS_SUBSCRIPTION } from "../services/app/edit/operation.js";
+import { DeployDisallowedError } from "../services/filesync/error.js";
+import { FileSync } from "../services/filesync/filesync.js";
+import { SyncJson, loadSyncJsonDirectory } from "../services/filesync/sync-json.js";
+import { confirm } from "../services/output/confirm.js";
+import { output } from "../services/output/output.js";
+import { println } from "../services/output/print.js";
+import { ProblemSeverity, printProblems, publishIssuesToProblems } from "../services/output/problems.js";
+import { reportErrorAndExit } from "../services/output/report.js";
+import { spin } from "../services/output/spinner.js";
 import { sprint } from "../services/output/sprint.js";
-import { isCloseEvent, isGraphQLErrors } from "../services/util/is.js";
-export const usage = ()=>sprint`
-    Deploy your Gadget application's development source code to production.
+import { ts } from "../services/output/timestamp.js";
+import { unreachable } from "../services/util/assert.js";
+import { isGraphQLErrors } from "../services/util/is.js";
+import { args as PushArgs } from "./push.js";
+export const args = {
+    ...PushArgs,
+    "--env": {
+        type: String,
+        alias: [
+            "-e",
+            "--environment",
+            "--from"
+        ]
+    },
+    "--allow-problems": {
+        type: Boolean,
+        alias: "--allow-issues"
+    },
+    "--allow-charges": {
+        type: Boolean
+    }
+};
+export const usage = (ctx)=>{
+    if (ctx.args["-h"]) {
+        return sprint`
+      Deploy an environment to production.
+
+      Your local files must match your environment's files
+      before you can deploy. Changes are tracked from
+      the last "ggt dev", "ggt push", or "ggt pull" run locally.
+
+      {bold USAGE}
+        ggt deploy
+
+      {bold EXAMPLES}
+        $ ggt deploy
+        $ ggt deploy --from=staging
+        $ ggt deploy --from=staging --force
+        $ ggt deploy --from=staging --force --allow-problems
+
+      {bold FLAGS}
+        -a, --app=<name>      The application to deploy
+        -e, --from=<env>      The environment to deploy from
+            --force           Discard changes to your environment's filesystem
+            --allow-problems  Deploy regardless of any problems the environment has
+            --allow-charges   Deploy even if doing so will add charges to your account
+
+      Run "ggt deploy --help" for more information.
+    `;
+    }
+    return sprint`
+    Deploy an environment to production.
+
+    Your local files must match your environment's files
+    before you can deploy. Changes are tracked from
+    the last "ggt dev", "ggt push", or "ggt pull" run locally.
+
+    If your local files don't match your environment's files, you will
+    be prompted to push your local files before you can deploy.
+
+    If your environment has un-pulled changes, and "--force" is not
+    passed, you will be prompted to {underline discard them} or abort the deploy.
 
     {bold USAGE}
-      ggt deploy [DIRECTORY] [--app=<name>]
 
-    {bold ARGUMENTS}
-      DIRECTORY         The directory to sync files to and deploy (default: ".")
+      ggt deploy [--app=<name>] [--from=<env>] [--force]
+                 [--allow-problems] [--allow-charges]
+
+    {bold EXAMPLES}
+
+      $ ggt deploy
+      $ ggt deploy --from=staging
+      $ ggt deploy --from=staging --force
+      $ ggt deploy --from=staging --force --allow-problems
+      $ ggt deploy --from=staging --force --allow-problems --allow-charges
 
     {bold FLAGS}
-      -a, --app=<name>  The Gadget application to deploy
-          --force       Deploy the Gadget application regardless of any issues it may have
 
-    {bold DESCRIPTION}
-      Deploy allows you to deploy your current Gadget application in development to production.
+      -a, --app, --application=<name>
+        The application to deploy.
+
+        Defaults to the application within the ".gadget/sync.json"
+        file in the current directory or any parent directories.
 
-      It detects if local files are up to date with remote and if the Gadget application
-      is in a deployable state. If there are any issues, it will display them and ask if
-      you would like to deploy anyways.
+      -e, --env, --environment, --from=<name>
+        The environment to deploy from.
 
-      Note:
-        • If local files are not up to date or have not recently been synced with remote ones,
-          you will be prompted to run a one-time sync to ensure the files remain consistent with
-          what is on the remote.
-        • You may wish to keep ggt sync running in the background before trying to run ggt deploy
+        Defaults to the environment within the ".gadget/sync.json"
+        file in the current directory or any parent directories.
 
-    {bold EXAMPLE}
-      $ ggt deploy ~/gadget/example --app example
+      -f, --force
+        Discard any changes made to your environment's filesystem
+        since the last "ggt dev", "ggt push", or "ggt pull".
 
-      App         example
-      Editor      https://example.gadget.app/edit
-      Playground  https://example.gadget.app/api/graphql/playground
-      Docs        https://docs.gadget.dev/api/example
+        Defaults to false.
 
-      Endpoints
-        • https://example.gadget.app
-        • https://example--development.gadget.app
+      --allow-problems, --allow-issues
+        Deploy your environment to production regardless of any problems
+        it may have.
 
+        These problems may include:
+          • Gelly syntax errors
+          • TypeScript errors
+          • Models with missing fields
 
-      Building frontend assets ...
-      ✔ DONE
+        Defaults to false.
 
-      Setting up database ...
-      ✔ DONE
+      --allow-charges
+        Allows "ggt deploy" to continue when deploying your environment
+        to production will add charges to your account.
 
-      Copying development ...
-      ✔ DONE
+        Defaults to false.
 
-      Restarting app ...
-      ✔ DONE
+      --allow-unknown-directory
+        Allows "ggt deploy" to continue when the current directory, nor
+        any parent directories, contain a ".gadget/sync.json" file
+        within it.
 
-      Deploy completed. Good bye!
+        Defaults to false.
+
+      --allow-different-app
+        Allows "ggt deploy" to continue with a different "--app" than the
+        one found within the ".gadget/sync.json" file.
+
+        Defaults to false.
+
+    Run "ggt deploy -h" for less information.
 `;
-export const args = {
-    ...FileSyncArgs
-};
-export var Action;
-(function(Action) {
-    Action["DEPLOY_ANYWAYS"] = "Deploy anyways";
-    Action["SYNC_ONCE"] = "Sync once";
-    Action["CANCEL"] = "Cancel (Ctrl+C)";
-})(Action || (Action = {}));
-const AppDeploymentStepsToAppDeployState = (step)=>{
-    switch(step){
-        case "NOT_STARTED":
-            return "Deploy not started";
-        case "STARTING":
-        case "BUILDING_ASSETS":
-        case "UPLOADING_ASSETS":
-            return "Building frontend assets";
-        case "CONVERGING_STORAGE":
-            return "Setting up database";
-        case "PUBLISHING_TREE":
-            return "Copying development";
-        case "RELOADING_SANDBOX":
-            return "Restarting app";
-        case "COMPLETED":
-            return "Deploy completed";
-        default:
-            return "Unknown step";
-    }
 };
-var AppDeploymentSteps;
-(function(AppDeploymentSteps) {
-    AppDeploymentSteps["NOT_STARTED"] = "NOT_STARTED";
-    AppDeploymentSteps["STARTING"] = "STARTING";
-    AppDeploymentSteps["BUILDING_ASSETS"] = "BUILDING_ASSETS";
-    AppDeploymentSteps["UPLOADING_ASSETS"] = "UPLOADING_ASSETS";
-    AppDeploymentSteps["CONVERGING_STORAGE"] = "CONVERGING_STORAGE";
-    AppDeploymentSteps["PUBLISHING_TREE"] = "PUBLISHING_TREE";
-    AppDeploymentSteps["RELOADING_SANDBOX"] = "RELOADING_SANDBOX";
-    AppDeploymentSteps["COMPLETED"] = "COMPLETED";
-})(AppDeploymentSteps || (AppDeploymentSteps = {}));
-const groupByProperty = (items, property)=>{
-    const grouped = {};
-    const defaultOtherIssues = "Other Issues";
-    for (const item of items){
-        if (item.node) {
-            const value = item.node[property];
-            if (value && !grouped[value]) {
-                grouped[value] = [];
-                grouped[value]?.push(item);
-            } else if (value && grouped[value]) {
-                grouped[value]?.push(item);
+export const command = async (ctx)=>{
+    const directory = await loadSyncJsonDirectory(process.cwd());
+    const syncJson = await SyncJson.loadOrInit(ctx, {
+        directory
+    });
+    println({
+        ensureEmptyLineAbove: true
+    })`
+    Deploying ${syncJson.env.name} to ${terminalLink(syncJson.app.primaryDomain, `https://${syncJson.app.primaryDomain}/`)}
+  `;
+    const filesync = new FileSync(syncJson);
+    const hashes = await filesync.hashes(ctx);
+    if (!hashes.inSync && (hashes.localChangesToPush.size > 0 || !hashes.onlyDotGadgetFilesChanged)) {
+        // the following is true:
+        //   1. our local files don't match our environment's files
+        //   2. we have local changes to push or non .gadget/ files have changed on our environment
+        //  therefor, we need to push before we can deploy
+        await filesync.print(ctx, {
+            hashes
+        });
+        println({
+            ensureEmptyLineAbove: true
+        })`
+      Your environment's files must match your local files before you can deploy.
+    `;
+        // some scenarios make the confirmation to push changes imply the
+        // --force flag (e.g. when both local and environment files have
+        // changed, or when only environment files have changed)
+        let implicitForce = false;
+        if (output.isInteractive) {
+            let message;
+            switch(true){
+                case hashes.bothChanged:
+                    message = sprint`Would you like to push your local changes and {underline discard your environment's} changes now?`;
+                    implicitForce = true;
+                    break;
+                case hashes.localChangesToPush.size > 0:
+                    message = sprint`Would you like to push your local changes now?`;
+                    break;
+                case hashes.environmentChanges.size > 0:
+                    message = sprint`Do you want to {underline discard your environment's} changes now?`;
+                    implicitForce = true;
+                    break;
+                default:
+                    unreachable("no changes to push or discard");
             }
+            await confirm({
+                ensureEmptyLineAbove: true
+            })(message);
         } else {
-            if (!grouped[defaultOtherIssues]) {
-                grouped[defaultOtherIssues] = [];
-            }
-            grouped[defaultOtherIssues].push(item);
+            println({
+                ensureEmptyLineAbove: true
+            })`
+        Assuming you want to push your local files now.
+      `;
         }
-    }
-    return grouped;
-};
-/**
- * Runs the deploy process.
- */ export const command = async (ctx, firstRun = true)=>{
-    const spinner = ora();
-    let prevProgress = AppDeploymentStepsToAppDeployState("NOT_STARTED");
-    let action;
-    // deploy --force != sync --force
-    const filesync = await FileSync.init(ctx.child({
-        overwrite: {
-            "--force": false
-        }
-    }));
-    if (firstRun) {
-        ctx.log.printlns`App: ${filesync.app.slug}`;
-    }
-    const { inSync } = await filesync.hashes();
-    if (!inSync) {
-        ctx.log.printlns`
-      Local files have diverged from remote. Run a sync once to converge your files or keep {italic ggt sync} running in the background.
-    `;
-        action = await select(ctx, {
-            message: "How would you like to proceed?",
-            choices: [
-                "Cancel (Ctrl+C)",
-                "Sync once"
-            ]
+        await filesync.push(ctx, {
+            hashes,
+            force: implicitForce || ctx.args["--force"]
         });
-        switch(action){
-            case "Sync once":
-                {
-                    await filesync.sync();
-                    break;
-                }
-            case "Cancel (Ctrl+C)":
-                {
-                    process.exit(0);
-                }
-        }
     }
-    // subscribes to the graphql subscription that will listen and send back the server contract status
-    const unsubscribe = filesync.edit.subscribe({
-        subscription: REMOTE_SERVER_CONTRACT_STATUS_SUBSCRIPTION,
-        variables: ()=>({
-                localFilesVersion: String(filesync.filesVersion),
-                force: ctx.args["--force"]
-            }),
-        onError: (error)=>{
-            if (isCloseEvent(error.cause)) {
-                spinner.fail("Failed");
-                ctx.log.printlns(error.message);
-            } else if (isGraphQLErrors(error.cause)) {
-                const message = error.cause[0]?.message;
-                if (message && message.includes("GGT_PAYMENT_REQUIRED")) {
-                    ctx.log.println("Production environment limit reached. Upgrade your plan to deploy");
-                } else {
-                    ctx.log.println(`${message}`);
-                }
-            }
+    const variables = {
+        localFilesVersion: String(syncJson.filesVersion),
+        force: ctx.args["--allow-problems"],
+        allowCharges: ctx.args["--allow-charges"]
+    };
+    let spinner;
+    let currentStep = AppDeploymentSteps.NOT_STARTED;
+    let printedProblems = false;
+    const subscription = syncJson.edit.subscribe({
+        subscription: PUBLISH_STATUS_SUBSCRIPTION,
+        variables,
+        onError: async (error)=>{
             ctx.log.error("failed to deploy", {
                 error
             });
-            unsubscribe();
-            return;
+            spinner?.fail(stepToSpinnerStart(syncJson, currentStep) + " " + ts());
+            if (isGraphQLErrors(error.cause)) {
+                const graphqlError = error.cause[0];
+                assert(graphqlError, "expected graphqlError to be defined");
+                switch(true){
+                    case graphqlError.extensions["requiresUpgrade"]:
+                        println({
+                            ensureEmptyLineAbove: true
+                        })(graphqlError.message.replace(/GGT_PAYMENT_REQUIRED:?\s*/, ""));
+                        process.exit(1);
+                        break;
+                    case graphqlError.extensions["requiresAdditionalCharge"]:
+                        println({
+                            ensureEmptyLineAbove: true
+                        })(graphqlError.message.replace(/GGT_PAYMENT_REQUIRED:?\s*/, ""));
+                        await confirm({
+                            ensureEmptyLineAbove: true
+                        })("Do you want to continue?");
+                        subscription.resubscribe({
+                            ...variables,
+                            allowCharges: true
+                        });
+                        return;
+                }
+            }
+            await reportErrorAndExit(ctx, error);
         },
         onData: async ({ publishStatus })=>{
-            const { progress, issues, status } = publishStatus ?? {};
-            const hasIssues = issues?.length;
-            if (firstRun && hasIssues) {
-                ctx.log.printlns`{underline Issues detected}`;
-                const printIssues = (groupedIssues)=>{
-                    for (const [name, nodeArray] of Object.entries(groupedIssues)){
-                        ctx.log.println(`\n\n • ${chalk.cyan(name)} ${chalk.redBright(nodeArray.length === 1 ? `${nodeArray.length} issue` : `${nodeArray.length} issues`)}${nodeArray.map((e)=>{
-                            if (!e.node) {
-                                return `\n\t   ${chalk.red("✖")} ${e.message}`;
-                            }
-                            return `\n\t   ${chalk.red("✖")} ${titleFormatter(e)}: ${e.nodeLabels?.map((label)=>`${chalk.bgWhite.black(label.type.toLowerCase())} ${chalk.white.bold(label.identifier)}`).join("")}`;
-                        }).join("")}`);
-                    }
-                };
-                const titleFormatter = (e)=>{
-                    if (e.node?.type === "SourceFile") {
-                        return `${chalk.magentaBright("Typescript")} ${e.message.replace(/[.,]+$/, "")}`;
-                    }
-                    return e.message.replace(/[.,]+$/, "");
-                };
-                const issuesWithNoNode = issues.filter((item)=>item.node?.apiIdentifier);
-                const groupedByApiIdentifier = groupByProperty(issuesWithNoNode, "apiIdentifier");
-                printIssues(groupedByApiIdentifier);
-                const remainingItems = issues.filter((item)=>!item.node?.apiIdentifier);
-                const groupedByName = groupByProperty(remainingItems, "name");
-                printIssues(groupedByName);
-                if (!ctx.args["--force"]) {
-                    unsubscribe();
-                    action = await select(ctx, {
-                        message: "Detected some issues with your app. How would you like to proceed?",
-                        choices: [
-                            "Cancel (Ctrl+C)",
-                            "Deploy anyways"
-                        ]
-                    });
-                    switch(action){
-                        case "Deploy anyways":
-                            {
-                                ctx.args["--force"] = true;
-                                await command(ctx, false);
-                                break;
-                            }
-                        case "Cancel (Ctrl+C)":
-                            {
-                                process.exit(0);
-                            }
-                    }
+            if (!publishStatus) {
+                ctx.log.warn("received empty publish status");
+                return;
+            }
+            const { publishStarted, progress: step, issues, status } = publishStatus;
+            if (!printedProblems && issues.length > 0) {
+                printedProblems = true;
+                const fatalIssues = issues.filter((issue)=>issue.severity === ProblemSeverity.Fatal);
+                if (fatalIssues.length > 0) {
+                    await reportErrorAndExit(ctx, new DeployDisallowedError(publishIssuesToProblems(fatalIssues)));
                 }
-                firstRun = false;
-            } else {
-                const publishStatus = status ? status : undefined;
-                const handleCompletion = (message, color)=>{
-                    spinner.stopAndPersist({
-                        symbol: color === "red" ? chalk.red("✖") : chalk.greenBright("✔"),
-                        text: color === "red" ? "Failed" : "DONE"
+                println({
+                    ensureEmptyLineAbove: true
+                })`{bold Problems found.}`;
+                printProblems({
+                    problems: publishIssuesToProblems(issues)
+                });
+                if (!publishStarted) {
+                    await confirm("Do you want to continue?");
+                    subscription.resubscribe({
+                        ...variables,
+                        force: true
                     });
-                    ctx.log.printlns(color === "red" ? chalk.red(message) : chalk.green(message));
-                    if (publishStatus?.output) {
-                        ctx.log.printlns(`Cmd/Ctrl + Click: \u001b]8;;${publishStatus.output}\u0007View Logs\u001b]8;;\u0007`);
-                    }
-                    unsubscribe();
-                };
-                if (publishStatus && "code" in publishStatus && publishStatus.code === "Errored") {
-                    handleCompletion(publishStatus.message, "red");
-                    return;
+                } else {
+                    assert(ctx.args["--allow-problems"], "expected --allow-problems to be true");
+                    println({
+                        ensureEmptyLineAbove: true
+                    })`Deploying regardless of problems because {bold "--allow-problems"} was passed.`;
+                }
+                return;
+            }
+            if (status?.code === "Errored") {
+                subscription.unsubscribe();
+                spinner?.fail(stepToSpinnerStart(syncJson, currentStep) + " " + ts());
+                if (status.message) {
+                    println({
+                        ensureEmptyLineAbove: true
+                    })`{red ${status.message}}`;
                 }
-                if (progress === "COMPLETED") {
-                    handleCompletion("Deploy completed. Good bye!", "green");
-                    return;
+                if (status.output) {
+                    println({
+                        ensureEmptyLineAbove: true
+                    })`${terminalLink("Check logs", status.output)}`;
                 }
-                const currentProgress = AppDeploymentStepsToAppDeployState(progress);
-                if (progress && currentProgress !== prevProgress) {
-                    if (progress !== "STARTING") {
-                        spinner.succeed("DONE");
-                    }
-                    prevProgress = currentProgress;
-                    ctx.log.printlns(`${currentProgress} ...`);
-                    spinner.start("Working ...");
+                return;
+            }
+            if (step === AppDeploymentSteps.COMPLETED) {
+                subscription.unsubscribe();
+                spinner?.succeed(stepToSpinnerEnd(syncJson, currentStep));
+                let message = sprint`{green Deploy successful!}`;
+                if (status?.output) {
+                    message += ` ${terminalLink("Check logs", status.output)}.`;
+                }
+                println({
+                    ensureEmptyLineAbove: true
+                })(message);
+                return;
+            }
+            if (step !== currentStep) {
+                const spinnerText = stepToSpinnerStart(syncJson, step);
+                if (spinnerText !== spinner?.text) {
+                    // stop the current spinner, if any, and start a new one
+                    spinner?.succeed(stepToSpinnerEnd(syncJson, currentStep));
+                    const ensureEmptyLineAbove = currentStep === AppDeploymentSteps.NOT_STARTED || !output.isInteractive;
+                    spinner = spin({
+                        ensureEmptyLineAbove
+                    })(spinnerText);
                 }
+                currentStep = step;
             }
         }
     });
 };
+export const AppDeploymentSteps = Object.freeze({
+    NOT_STARTED: "NOT_STARTED",
+    STARTING: "STARTING",
+    BUILDING_ASSETS: "BUILDING_ASSETS",
+    UPLOADING_ASSETS: "UPLOADING_ASSETS",
+    CONVERGING_STORAGE: "CONVERGING_STORAGE",
+    PUBLISHING_TREE: "PUBLISHING_TREE",
+    RELOADING_SANDBOX: "RELOADING_SANDBOX",
+    COMPLETED: "COMPLETED"
+});
+export const stepToSpinnerStart = (syncJson, step)=>{
+    switch(step){
+        case AppDeploymentSteps.NOT_STARTED:
+        case AppDeploymentSteps.STARTING:
+        case AppDeploymentSteps.BUILDING_ASSETS:
+        case AppDeploymentSteps.UPLOADING_ASSETS:
+            return "Building frontend assets.";
+        case AppDeploymentSteps.CONVERGING_STORAGE:
+            return "Setting up database.";
+        case AppDeploymentSteps.PUBLISHING_TREE:
+            return `Copying ${syncJson.env.name}.`;
+        case AppDeploymentSteps.RELOADING_SANDBOX:
+            return "Restarting app.";
+        case AppDeploymentSteps.COMPLETED:
+            return "Deploy complete!";
+        default:
+            return "Unknown step.";
+    }
+};
+export const stepToSpinnerEnd = (syncJson, step)=>{
+    switch(step){
+        case AppDeploymentSteps.NOT_STARTED:
+        case AppDeploymentSteps.STARTING:
+        case AppDeploymentSteps.BUILDING_ASSETS:
+        case AppDeploymentSteps.UPLOADING_ASSETS:
+            return `Built frontend assets. ${ts()}`;
+        case AppDeploymentSteps.CONVERGING_STORAGE:
+            return `Setup database. ${ts()}`;
+        case AppDeploymentSteps.PUBLISHING_TREE:
+            return `Copied ${syncJson.env.name}. ${ts()}`;
+        case AppDeploymentSteps.RELOADING_SANDBOX:
+            return `Restarted app. ${ts()}`;
+        case AppDeploymentSteps.COMPLETED:
+            return "Deploy successful!";
+        default:
+            return `Completed unknown step. ${ts()}`;
+    }
+};
 
 //# sourceMappingURL=deploy.js.map