@prisma/compute-cli 0.1.0

package/src/commands/services.ts

@@ -0,0 +1,385 @@
+import { ComputeClient } from "@prisma/compute-sdk";
+import { defineCommand } from "citty";
+import { formatTable } from "../lib/format.ts";
+import {
+  createDeployInteraction,
+  isInteractiveSession,
+  promptForConfirmation,
+} from "../lib/interaction.ts";
+import { printJsonResult } from "../lib/json-output.ts";
+import { createDestroyServiceProgress } from "../lib/progress.ts";
+import {
+  endFlow,
+  handleError,
+  parsePollOptions,
+  startFlow,
+  withAuthAndSignal,
+} from "./helpers.ts";
+
+const servicesListCommand = defineCommand({
+  meta: { name: "list", description: "List compute services" },
+  args: {
+    project: { type: "string", description: "Project ID" },
+    json: { type: "boolean", default: false, description: "Output JSON" },
+  },
+  run: async ({ args }) => {
+    const exitCode = await withAuthAndSignal(
+      async (managementClient, signal) => {
+        const flowStarted =
+          !args.json && startFlow("Prisma Compute · Services");
+
+        try {
+          const sdk = new ComputeClient(managementClient);
+
+          let projectId = args.project;
+          if (!projectId) {
+            const interaction = args.json
+              ? undefined
+              : createDeployInteraction();
+            if (!interaction?.selectProject) {
+              console.error("Missing required flag: --project <id>");
+              return 1;
+            }
+            const projectsResult = await sdk.listProjects({ signal });
+            if (projectsResult.isErr()) {
+              console.error(projectsResult.error.message);
+              return 1;
+            }
+            projectId = await interaction.selectProject(projectsResult.value);
+          }
+
+          const result = await sdk.listServices({ projectId, signal });
+
+          if (args.json) {
+            printJsonResult(result);
+            return result.isOk() ? 0 : 1;
+          }
+
+          if (result.isErr()) {
+            console.error(result.error.message);
+            return 1;
+          }
+
+          if (result.value.length === 0) {
+            console.log("No compute services found.");
+            endFlow(flowStarted);
+            return 0;
+          }
+
+          console.log(
+            formatTable(
+              ["ID", "Name", "Region"],
+              result.value.map((s) => [s.id, s.name, s.region]),
+            ),
+          );
+          endFlow(flowStarted);
+          return 0;
+        } catch (error) {
+          return handleError(error);
+        }
+      },
+    );
+
+    if (exitCode !== 0) process.exit(exitCode);
+  },
+});
+
+const servicesCreateCommand = defineCommand({
+  meta: { name: "create", description: "Create a compute service" },
+  args: {
+    project: { type: "string", description: "Project ID" },
+    name: { type: "string", description: "Service display name" },
+    region: { type: "string", description: "Region ID" },
+    json: { type: "boolean", default: false, description: "Output JSON" },
+  },
+  run: async ({ args }) => {
+    const exitCode = await withAuthAndSignal(
+      async (managementClient, signal) => {
+        const flowStarted =
+          !args.json && startFlow("Prisma Compute · Services");
+
+        try {
+          const sdk = new ComputeClient(managementClient);
+          const interaction = args.json ? undefined : createDeployInteraction();
+
+          let projectId = args.project;
+          if (!projectId) {
+            if (!interaction?.selectProject) {
+              console.error("Missing required flag: --project <id>");
+              return 1;
+            }
+            const projectsResult = await sdk.listProjects({ signal });
+            if (projectsResult.isErr()) {
+              console.error(projectsResult.error.message);
+              return 1;
+            }
+            projectId = await interaction.selectProject(projectsResult.value);
+          }
+
+          let serviceName = args.name;
+          if (!serviceName) {
+            if (!interaction?.provideServiceName) {
+              console.error("Missing required flag: --name <name>");
+              return 1;
+            }
+            serviceName = await interaction.provideServiceName();
+          }
+
+          let region = args.region;
+          if (!region) {
+            if (!interaction?.selectRegion) {
+              console.error("Missing required flag: --region <region>");
+              return 1;
+            }
+            const { REGIONS } = await import("@prisma/compute-sdk");
+            region = await interaction.selectRegion(REGIONS);
+          }
+
+          const result = await sdk.createService({
+            projectId,
+            serviceName,
+            region,
+            signal,
+          });
+
+          if (args.json) {
+            printJsonResult(result);
+            return result.isOk() ? 0 : 1;
+          }
+
+          if (result.isErr()) {
+            console.error(result.error.message);
+            return 1;
+          }
+
+          console.log(
+            `Created compute service ${result.value.name} (${result.value.id})`,
+          );
+          endFlow(flowStarted);
+          return 0;
+        } catch (error) {
+          return handleError(error);
+        }
+      },
+    );
+
+    if (exitCode !== 0) process.exit(exitCode);
+  },
+});
+
+const servicesShowCommand = defineCommand({
+  meta: { name: "show", description: "Show compute service details" },
+  args: {
+    id: {
+      type: "positional",
+      description: "Compute service ID",
+      required: false,
+    },
+    json: { type: "boolean", default: false, description: "Output JSON" },
+  },
+  run: async ({ args }) => {
+    const exitCode = await withAuthAndSignal(
+      async (managementClient, signal) => {
+        try {
+          const sdk = new ComputeClient(managementClient);
+          const serviceId = args.id;
+
+          if (!serviceId) {
+            console.error("Usage: compute services show <id>");
+            return 1;
+          }
+
+          const result = await sdk.showService({ serviceId, signal });
+
+          if (args.json) {
+            printJsonResult(result);
+            return result.isOk() ? 0 : 1;
+          }
+
+          if (result.isErr()) {
+            console.error(result.error.message);
+            return 1;
+          }
+
+          const s = result.value;
+          console.log(`ID:       ${s.id}`);
+          console.log(`Name:     ${s.name}`);
+          console.log(`Region:   ${s.region}`);
+          console.log(`Project:  ${s.projectId ?? "-"}`);
+          if (s.latestVersionId) {
+            console.log(`Latest Version: ${s.latestVersionId}`);
+          }
+          return 0;
+        } catch (error) {
+          return handleError(error);
+        }
+      },
+    );
+
+    if (exitCode !== 0) process.exit(exitCode);
+  },
+});
+
+const servicesDeleteCommand = defineCommand({
+  meta: { name: "delete", description: "Delete a compute service" },
+  args: {
+    id: {
+      type: "positional",
+      description: "Compute service ID",
+      required: false,
+    },
+    json: { type: "boolean", default: false, description: "Output JSON" },
+  },
+  run: async ({ args }) => {
+    const exitCode = await withAuthAndSignal(
+      async (managementClient, signal) => {
+        try {
+          const sdk = new ComputeClient(managementClient);
+          const serviceId = args.id;
+
+          if (!serviceId) {
+            console.error("Usage: compute services delete <id>");
+            return 1;
+          }
+
+          if (!args.json && isInteractiveSession()) {
+            const confirmed = await promptForConfirmation(
+              `Delete service ${serviceId}?`,
+            );
+            if (!confirmed) {
+              console.log("Delete cancelled.");
+              return 0;
+            }
+          }
+
+          const result = await sdk.deleteService({ serviceId, signal });
+
+          if (args.json) {
+            printJsonResult(result);
+            return result.isOk() ? 0 : 1;
+          }
+
+          if (result.isErr()) {
+            console.error(result.error.message);
+            return 1;
+          }
+
+          console.log(`Deleted compute service: ${serviceId}`);
+          return 0;
+        } catch (error) {
+          return handleError(error);
+        }
+      },
+    );
+
+    if (exitCode !== 0) process.exit(exitCode);
+  },
+});
+
+const servicesDestroyCommand = defineCommand({
+  meta: {
+    name: "destroy",
+    description:
+      "Destroy a service: stop and delete all versions, then delete the service",
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "Compute service ID",
+      required: false,
+    },
+    keepService: {
+      type: "boolean",
+      default: false,
+      description: "Keep the service, only destroy versions",
+    },
+    timeout: {
+      type: "string",
+      default: "120",
+      description: "Poll timeout in seconds",
+    },
+    pollInterval: {
+      type: "string",
+      default: "1000",
+      description: "Poll interval in milliseconds",
+    },
+    json: { type: "boolean", default: false, description: "Output JSON" },
+  },
+  run: async ({ args }) => {
+    const exitCode = await withAuthAndSignal(
+      async (managementClient, signal) => {
+        const flowStarted =
+          !args.json && startFlow("Prisma Compute · Services");
+
+        try {
+          const sdk = new ComputeClient(managementClient);
+          const serviceId = args.id;
+
+          if (!serviceId) {
+            console.error("Usage: compute services destroy <id>");
+            return 1;
+          }
+
+          if (!args.json && isInteractiveSession()) {
+            const action = args.keepService
+              ? "stop and delete all its versions"
+              : "stop and delete all versions, then delete the service";
+            const confirmed = await promptForConfirmation(
+              `Destroy service ${serviceId}? This will ${action}.`,
+            );
+            if (!confirmed) {
+              console.log("Destroy cancelled.");
+              endFlow(flowStarted);
+              return 0;
+            }
+          }
+
+          const result = await sdk.destroyService({
+            serviceId,
+            keepService: args.keepService,
+            ...parsePollOptions(args),
+            progress: args.json ? undefined : createDestroyServiceProgress(),
+            signal,
+          });
+
+          if (args.json) {
+            printJsonResult(result);
+            return result.isOk() ? 0 : 1;
+          }
+
+          if (result.isErr()) {
+            const err = result.error;
+            if (err._tag === "DestroyAggregateError") {
+              for (const f of err.failures) {
+                console.error(`${f.versionId}: ${f.error.message}`);
+              }
+            } else {
+              console.error(err.message);
+            }
+            return 1;
+          }
+
+          const suffix = args.keepService ? " (service kept)" : "";
+          console.log(`Destroyed service: ${serviceId}${suffix}`);
+          endFlow(flowStarted);
+          return 0;
+        } catch (error) {
+          return handleError(error);
+        }
+      },
+    );
+
+    if (exitCode !== 0) process.exit(exitCode);
+  },
+});
+
+export const servicesGroup = defineCommand({
+  meta: { name: "services", description: "Compute service management" },
+  subCommands: {
+    list: servicesListCommand,
+    create: servicesCreateCommand,
+    show: servicesShowCommand,
+    delete: servicesDeleteCommand,
+    destroy: servicesDestroyCommand,
+  },
+});