@superblocksteam/cli 1.13.1 → 1.14.1

package/README.md

@@ -12,7 +12,7 @@ $ npm install -g @superblocksteam/cli
 $ superblocks COMMAND
 running command...
 $ superblocks (--version)
-@superblocksteam/cli/1.13.1 linux-x64 node-v20.19.0
+@superblocksteam/cli/1.14.1 linux-x64 node-v20.19.0
 $ superblocks --help [COMMAND]
 USAGE
   $ superblocks COMMAND
@@ -27,6 +27,7 @@ USAGE
 * [`superblocks components upload`](#superblocks-components-upload)
 * [`superblocks components watch`](#superblocks-components-watch)
 * [`superblocks config set PROPERTY VALUE`](#superblocks-config-set-property-value)
+* [`superblocks deploy [RESOURCE_PATH]`](#superblocks-deploy-resource_path)
 * [`superblocks help [COMMAND]`](#superblocks-help-command)
 * [`superblocks init [RESOURCE_URL]`](#superblocks-init-resource_url)
 * [`superblocks login`](#superblocks-login)
@@ -150,6 +151,33 @@ EXAMPLES
   $ superblocks config set domain app.superblocks.com
 ```
 
+## `superblocks deploy [RESOURCE_PATH]`
+
+Deploy resources to Superblocks
+
+```
+USAGE
+  $ superblocks deploy [RESOURCE_PATH] [-c <value>]
+
+ARGUMENTS
+  RESOURCE_PATH  The path to the resource to deploy
+
+FLAGS
+  -c, --commit-id=<value>  The commit ID to deploy
+
+DESCRIPTION
+  Deploy resources to Superblocks
+
+EXAMPLES
+  $ superblocks deploy
+
+  $ superblocks deploy  apps/my-app
+
+  $ superblocks deploy  apps/my-app --commit-id commit-id
+
+  $ superblocks deploy  --commit-id commit-id
+```
+
 ## `superblocks help [COMMAND]`
 
 Display help for superblocks.

package/assets/custom-components/setup/package.json

@@ -7,7 +7,7 @@
     "lint:fix": "npx eslint . --fix"
   },
   "dependencies": {
-    "@superblocksteam/custom-components": "1.13.1",
+    "@superblocksteam/custom-components": "1.14.1",
     "react": "^18",
     "react-dom": "^18"
   },

package/dist/commands/components/create.mjs

@@ -313,6 +313,6 @@ export default class CreateComponent extends AuthenticatedApplicationCommand {
         const headers = {
             [COMPONENT_EVENT_HEADER]: ComponentEvent.CREATE,
         };
-        this.registerComponents(headers);
+        await this.registerComponents(headers);
     }
 }

package/dist/commands/deploy.d.mts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../common/authenticated-command.mjs";
+export default class Deploy extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        "commit-id": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        resource_path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private createTasks;
+    private getResourceIdsToDeploy;
+}

package/dist/commands/deploy.mjs

@@ -0,0 +1,302 @@
+import path from "node:path";
+import { Args, Flags } from "@oclif/core";
+import { ValidateGitSetupError } from "@superblocksteam/sdk";
+import { ComponentEvent, getSuperblocksMonorepoConfigJson, getSuperblocksResourceConfigIfExists, } from "@superblocksteam/util";
+import { ForbiddenError, BadRequestError, NotFoundError, } from "@superblocksteam/util";
+import { green, yellow } from "colorette";
+import { Listr } from "listr2";
+import { isEmpty } from "lodash-es";
+import { AuthenticatedCommand } from "../common/authenticated-command.mjs";
+import { atLeastOneSelection, isCI, MULTI_SELECT_PROMPT_HELP, } from "../common/version-control.mjs";
+var DeploymentStatus;
+(function (DeploymentStatus) {
+    DeploymentStatus["SUCCESS"] = "SUCCESS";
+    DeploymentStatus["FAILED"] = "FAILED";
+    DeploymentStatus["SKIPPED"] = "SKIPPED";
+})(DeploymentStatus || (DeploymentStatus = {}));
+const BATCH_DEPLOY_SIZE = 5;
+export default class Deploy extends AuthenticatedCommand {
+    static description = "Deploy resources to Superblocks";
+    static examples = [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %>  apps/my-app",
+        "<%= config.bin %> <%= command.id %>  apps/my-app --commit-id commit-id",
+        "<%= config.bin %> <%= command.id %>  --commit-id commit-id",
+    ];
+    static flags = {
+        "commit-id": Flags.string({
+            char: "c",
+            description: "The commit ID to deploy",
+            required: false,
+        }),
+    };
+    static args = {
+        resource_path: Args.string({
+            description: "The path to the resource to deploy",
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Deploy);
+        const tasks = this.createTasks(args.resource_path, flags["commit-id"]);
+        await tasks.run();
+    }
+    createTasks(resourcePath, commitId) {
+        const tasks = new Listr([
+            {
+                title: "Checking for existing Superblocks project...",
+                task: async (ctx) => {
+                    ctx.resourcePath = resourcePath;
+                    ctx.commitId = commitId;
+                    ctx.resourceIdsToSkip = new Set();
+                    try {
+                        [
+                            ctx.existingSuperblocksRootConfig,
+                            ctx.superblocksRootConfigPath,
+                        ] = await getSuperblocksMonorepoConfigJson(true);
+                        ctx.existingSuperblocksResourceConfig =
+                            await getSuperblocksResourceConfigIfExists();
+                        ctx.superblocksRootPath = path.resolve(path.dirname(ctx.superblocksRootConfigPath), "..");
+                    }
+                    catch {
+                        this.error("No Superblocks project found in the current folder hierarchy. Run 'superblocks init' to initialize a new project.");
+                    }
+                },
+            },
+            {
+                title: "Determining what resources to deploy...",
+                task: async (ctx, task) => {
+                    const resourceIdsToDeploy = await this.getResourceIdsToDeploy(ctx, task, resourcePath);
+                    ctx.resourcesToDeploy = resourceIdsToDeploy.map((resourceId) => {
+                        const resourceConfig = ctx.existingSuperblocksRootConfig?.resources[resourceId];
+                        return {
+                            resourceId: resourceId,
+                            resourceType: resourceConfig?.resourceType,
+                            location: resourceConfig?.location,
+                        };
+                    });
+                },
+            },
+            {
+                title: "Validating git configuration...",
+                task: async (ctx, task) => {
+                    const subtasks = [];
+                    for (const resource of ctx.resourcesToDeploy) {
+                        const resourceTitle = `${(resource.resourceType ?? "").toLowerCase()} ${resource.location}`;
+                        subtasks.push({
+                            title: `Checking ${resourceTitle}...`,
+                            task: async () => {
+                                try {
+                                    await this.validateGitSetup(resource.resourceType, resource.resourceId, ComponentEvent.DEPLOY);
+                                }
+                                catch (error) {
+                                    if (isCI() && error instanceof ValidateGitSetupError) {
+                                        this.log(`WARN: Failed to validate git setup for ${resourceTitle}. Skipping deploy for this resource.\n\n${error.message}.`);
+                                        ctx.resourceIdsToSkip.add(resource.resourceId);
+                                    }
+                                    else {
+                                        throw error;
+                                    }
+                                }
+                            },
+                        });
+                    }
+                    return task.newListr(subtasks, {
+                        concurrent: true,
+                    });
+                },
+            },
+            {
+                task: async (ctx, task) => {
+                    const subtasks = [];
+                    const resourcesToDeploy = ctx.resourcesToDeploy;
+                    task.title = `Deploying ${resourcesToDeploy.length} resources:`;
+                    const resourceDeploymentResolvers = [];
+                    const resourceDeploymentErrors = [];
+                    const resourcesStatuses = [];
+                    // Create all deployment tasks upfront to have statuses
+                    resourcesToDeploy.forEach((resource) => {
+                        const resourceConfig = ctx.existingSuperblocksRootConfig?.resources[resource.resourceId];
+                        const resourceTitle = `${(resourceConfig.resourceType ?? "").toLowerCase()} ${resourceConfig.location}`;
+                        const promise = new Promise((resolve) => {
+                            resourceDeploymentResolvers.push(resolve);
+                            resourcesStatuses.push({
+                                message: "",
+                            });
+                        });
+                        if (ctx.resourceIdsToSkip.has(resource.resourceId)) {
+                            subtasks.push({
+                                title: resourceTitle,
+                                options: {
+                                    showSubtasks: true,
+                                    skip: true,
+                                },
+                                task: async (_ctx, task) => {
+                                    task.title = `${resourceTitle} skipped`;
+                                },
+                            });
+                        }
+                        else {
+                            subtasks.push({
+                                title: resourceTitle,
+                                options: { showSubtasks: true, spinner: true },
+                                task: async (_ctx, task) => {
+                                    const result = await promise;
+                                    if (result.status === DeploymentStatus.SUCCESS) {
+                                        task.title = `${resourceTitle} deployed with commit ${result.commitId}`;
+                                    }
+                                    else if (result.status === DeploymentStatus.SKIPPED) {
+                                        const skipMessage = `${yellow("[!]")} ${resourceTitle} deployment skipped: ${result.error}`;
+                                        task.skip(skipMessage);
+                                    }
+                                    else if (result.status === DeploymentStatus.FAILED) {
+                                        task.title = `${resourceTitle} failed with error: ${result.error}`;
+                                        throw new Error(`FAILURE: ${resourceTitle}: Deploy failed with error: ${result.error}`);
+                                    }
+                                },
+                            });
+                        }
+                    });
+                    // Create hidden tasks for batch requests to server
+                    subtasks.push({
+                        title: "",
+                        task: async () => {
+                            try {
+                                for (let resourceIdx = 0; resourceIdx < resourcesToDeploy.length; resourceIdx += BATCH_DEPLOY_SIZE) {
+                                    const resourceBatch = resourcesToDeploy.slice(resourceIdx, resourceIdx + BATCH_DEPLOY_SIZE);
+                                    // Create a batch of promises for concurrent execution
+                                    const deployPromises = resourceBatch.map(async (resource, resultIdx) => {
+                                        const taskIndex = resourceIdx + resultIdx;
+                                        const resourceTitle = `${(resource.resourceType ?? "").toLowerCase()} ${resource.location}`;
+                                        if (ctx.resourceIdsToSkip.has(resource.resourceId)) {
+                                            return;
+                                        }
+                                        try {
+                                            let result;
+                                            if (resource.resourceType === "APPLICATION") {
+                                                result = await this.getSdk().deployApplication(resource.resourceId, commitId);
+                                            }
+                                            else if (resource.resourceType === "BACKEND") {
+                                                result = await this.getSdk().deployApi(resource.resourceId, commitId);
+                                            }
+                                            else {
+                                                throw new Error(`Unsupported resource type: ${resource.resourceType}`);
+                                            }
+                                            resourceDeploymentResolvers[taskIndex]({
+                                                status: DeploymentStatus.SUCCESS,
+                                                commitId: result.commitId,
+                                            });
+                                            resourcesStatuses[taskIndex].status =
+                                                DeploymentStatus.SUCCESS;
+                                            resourcesStatuses[taskIndex].message =
+                                                `${resourceTitle} deployed with commit ${result.commitId}`;
+                                        }
+                                        catch (error) {
+                                            if (error instanceof ForbiddenError ||
+                                                error instanceof BadRequestError ||
+                                                error instanceof NotFoundError) {
+                                                resourceDeploymentResolvers[taskIndex]({
+                                                    status: DeploymentStatus.SKIPPED,
+                                                    error: error.message,
+                                                });
+                                                resourcesStatuses[taskIndex].status =
+                                                    DeploymentStatus.SKIPPED;
+                                                resourcesStatuses[taskIndex].message =
+                                                    `${resourceTitle} deployment skipped: ${error.message}`;
+                                            }
+                                            else {
+                                                resourceDeploymentResolvers[taskIndex]({
+                                                    status: DeploymentStatus.FAILED,
+                                                    error: error.message,
+                                                });
+                                                resourceDeploymentErrors.push(new Error(`FAILURE: ${resourceTitle}: Deploy failed with error: ${error.message}`));
+                                            }
+                                        }
+                                    });
+                                    // Wait for all promises in this batch to complete
+                                    await Promise.all(deployPromises);
+                                }
+                            }
+                            finally {
+                                const header = "===================================";
+                                if (resourceDeploymentErrors.length > 0) {
+                                    this.log(`${header} ERRORS ${header}`);
+                                    resourceDeploymentErrors.forEach((e) => this.log(e.message));
+                                }
+                                else {
+                                    this.log(`${header} STATUSES ${header}`);
+                                    resourcesStatuses.forEach((statuses) => {
+                                        if (statuses.status === DeploymentStatus.SUCCESS) {
+                                            this.log(`${green("✔")} ${statuses.message}`);
+                                        }
+                                        else if (statuses.status === DeploymentStatus.SKIPPED) {
+                                            this.log(`${yellow("[!]")} ${statuses.message}`);
+                                        }
+                                    });
+                                }
+                            }
+                        },
+                    });
+                    return task.newListr(subtasks, {
+                        concurrent: true,
+                        exitOnError: false,
+                        persistentOutput: true,
+                        collapse: false,
+                        showSubtasks: true,
+                    });
+                },
+            },
+        ], {
+            concurrent: false,
+        });
+        return tasks;
+    }
+    async getResourceIdsToDeploy(ctx, task, resourcePath, supportedResourceTypes = ["APPLICATION", "BACKEND"]) {
+        const resources = Object.entries(ctx.existingSuperblocksRootConfig?.resources ?? {}).filter(([, resource]) => {
+            return supportedResourceTypes.includes(resource.resourceType);
+        });
+        if (isEmpty(resources)) {
+            throw new Error("No resources found in the current project");
+        }
+        else if (!isEmpty(resourcePath)) {
+            const resource = resources.find(([, resource]) => resource.location === resourcePath);
+            if (resource) {
+                return [resource[0]];
+            }
+            throw new Error(`No resource found with the given location: ${resourcePath}`);
+        }
+        const resourceConfig = await getSuperblocksResourceConfigIfExists();
+        if (resourceConfig) {
+            return [resourceConfig.id];
+        }
+        const choices = [];
+        const initialSelections = [];
+        let counter = 0;
+        for (const [resourceId, resource] of resources) {
+            choices.push({
+                name: resourceId,
+                message: resource.location,
+            });
+            if (ctx.existingSuperblocksResourceConfig?.id === resourceId) {
+                initialSelections.push(counter);
+            }
+            counter++;
+        }
+        const resourcesToDeploy = choices.length === 1
+            ? [choices[0].name]
+            : await task.prompt([
+                {
+                    type: "AutoComplete",
+                    name: "resourcesToDeploy",
+                    message: `Select resources to deploy (${MULTI_SELECT_PROMPT_HELP})`,
+                    choices: choices,
+                    initial: initialSelections,
+                    multiple: true,
+                    validate: atLeastOneSelection,
+                    prefix: "▸",
+                    indicator: "◉",
+                },
+            ]);
+        return resourcesToDeploy;
+    }
+}

package/dist/commands/init.mjs

@@ -235,6 +235,9 @@ export default class Initialize extends AuthenticatedCommand {
                     }
                     // create superblocks.json file
                     await fs.writeFile(ctx.superblocksRootConfigPath ?? RESOURCE_CONFIG_PATH, JSON.stringify(sortByKey(superblocksConfig), null, 2));
+                    if (ctx.existingSuperblocksRootConfig) {
+                        this.log(`Superblocks resources added at ${ctx.superblocksRootConfigPath?.replace(RESOURCE_CONFIG_PATH, "")}`);
+                    }
                 },
             },
         ], {

package/oclif.manifest.json

@@ -59,6 +59,47 @@
         "commits.mjs"
       ]
     },
+    "deploy": {
+      "aliases": [],
+      "args": {
+        "resource_path": {
+          "description": "The path to the resource to deploy",
+          "name": "resource_path",
+          "required": false
+        }
+      },
+      "description": "Deploy resources to Superblocks",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %>  apps/my-app",
+        "<%= config.bin %> <%= command.id %>  apps/my-app --commit-id commit-id",
+        "<%= config.bin %> <%= command.id %>  --commit-id commit-id"
+      ],
+      "flags": {
+        "commit-id": {
+          "char": "c",
+          "description": "The commit ID to deploy",
+          "name": "commit-id",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "deploy",
+      "pluginAlias": "@superblocksteam/cli",
+      "pluginName": "@superblocksteam/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "deploy.mjs"
+      ]
+    },
     "init": {
       "aliases": [],
       "args": {
@@ -446,5 +487,5 @@
       ]
     }
   },
-  "version": "1.13.1"
+  "version": "1.14.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superblocksteam/cli",
-  "version": "1.13.1",
+  "version": "1.14.1",
   "description": "Official Superblocks CLI",
   "bin": {
     "superblocks": "./bin/run"
@@ -17,7 +17,7 @@
   "dependencies": {
     "@oclif/core": "^4.2.8",
     "@oclif/plugin-help": "^6.2.26",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@vitejs/plugin-react": "4.3.4",
     "axios": "^1.4.0",
     "colorette": "^2.0.20",
     "enquirer": "^2.4.1",
@@ -29,8 +29,8 @@
     "slugify": "^1.6.6",
     "vite": "^6.2.0",
     "yaml": "^2.6.1",
-    "@superblocksteam/sdk": "1.13.1",
-    "@superblocksteam/util": "1.13.1"
+    "@superblocksteam/sdk": "1.14.1",
+    "@superblocksteam/util": "1.14.1"
   },
   "devDependencies": {
     "@oclif/test": "^4.1.11",
@@ -55,6 +55,7 @@
     "oclif": "^4.17.32",
     "prettier": "^3.5.2",
     "shx": "^0.3.3",
+    "sinon": "^20.0.0",
     "ts-node": "^10.9.1",
     "tslib": "^2.8.0",
     "typescript": "^5.7.0",
@@ -97,7 +98,7 @@
     "lint:fix": "eslint . --fix",
     "check": "pnpm run lint && pnpm run typecheck",
     "posttest": "npm run lint",
-    "test": "NODE_OPTIONS='--loader ts-node/esm' mocha --forbid-only \"test/**/*.test.*ts\"",
+    "test": "NODE_OPTIONS='--loader ts-node/esm/transpile-only --trace-warnings' mocha --forbid-only \"test/**/*.test.*ts\"",
     "typecheck": "tsc --noEmit",
     "update-readme": "oclif readme"
   }