feat: handle federated graph creation

Author: comatory

cli/src/commands/demo/command.ts

@@ -5,7 +5,7 @@ import pc from 'picocolors';
 import ora from 'ora';
 import { program } from 'commander';
 import { z } from 'zod';
-import type { WhoAmIResponse } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb';
+import type { FederatedGraph, Subgraph, WhoAmIResponse } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb';
 import { EnumStatusCode } from '@wundergraph/cosmo-connect/dist/common/common_pb';
 import { BaseCommandOptions } from '../../core/types/types.js';
 import { getBaseHeaders, config } from '../../core/config.js';
@@ -14,6 +14,10 @@ import { waitForKeyPress, rainbow, visibleLength } from '../../utils.js';
 const ONBOARDING_REPO = 'wundergraph/cosmo-onboarding';
 const ONBOARDING_BRANCH = 'main';
 const ONBOARDING_DIR_PREFIX = 'plugins/';
+const DEMO_GRAPH_NAME = 'demo' as const;
+const DEMO_NAMESPACES = 'default' as const;
+const DEMO_LABEL_MATCHER = `graph=demo` as const;
+const DEMO_ROUTER_PORT = 3002 as const;
 
 const GitHubTreeSchema = z.object({
   tree: z.array(
@@ -89,6 +93,298 @@ function printHello() {
   console.log('This command will guide you through the inital setup to create your first federated graph.');
 }
 
+async function fetchFederatedGraphByName(
+  client: BaseCommandOptions['client'],
+  { name, namespace }: { name: string; namespace: string },
+) {
+  const { response, graph, subgraphs } = await client.platform.getFederatedGraphByName(
+    {
+      name,
+      namespace,
+    },
+    {
+      headers: getBaseHeaders(),
+    },
+  );
+
+  switch (response?.code) {
+    case EnumStatusCode.OK: {
+      return { data: { graph, subgraphs }, error: null };
+    }
+    case EnumStatusCode.ERR_NOT_FOUND: {
+      return { data: null, error: null };
+    }
+    default: {
+      return {
+        data: null,
+        error: new Error(response?.details ?? 'An unknown error occured'),
+      };
+    }
+  }
+}
+
+async function cleanUpFederatedGraph(
+  client: BaseCommandOptions['client'],
+  graphData: {
+    graph: FederatedGraph;
+    subgraphs: Subgraph[];
+  },
+) {
+  const subgraphDeleteResponses = await Promise.all(
+    graphData.subgraphs.map(({ name, namespace }) =>
+      client.platform.deleteFederatedSubgraph(
+        {
+          namespace,
+          subgraphName: name,
+          disableResolvabilityValidation: false,
+        },
+        {
+          headers: getBaseHeaders(),
+        },
+      ),
+    ),
+  );
+
+  const failedSubgraphDeleteResponses = subgraphDeleteResponses.filter(
+    ({ response }) => response?.code !== EnumStatusCode.OK,
+  );
+
+  if (failedSubgraphDeleteResponses.length > 0) {
+    return {
+      error: new Error(
+        failedSubgraphDeleteResponses.map(({ response }) => response?.details ?? 'Unknown error occurred.').join('. '),
+      ),
+    };
+  }
+
+  const federatedGraphDeleteResponse = await client.platform.deleteFederatedGraph(
+    {
+      name: graphData.graph.name,
+      namespace: graphData.graph.namespace,
+    },
+    {
+      headers: getBaseHeaders(),
+    },
+  );
+
+  switch (federatedGraphDeleteResponse.response?.code) {
+    case EnumStatusCode.OK: {
+      return {
+        error: null,
+      };
+    }
+    default: {
+      return {
+        error: new Error(federatedGraphDeleteResponse.response?.details ?? 'Unknown error occurred.'),
+      };
+    }
+  }
+}
+
+async function createFederatedGraph(
+  client: BaseCommandOptions['client'],
+  options: {
+    name: string;
+    namespace: string;
+    labelMatcher: string;
+    routingUrl: URL;
+  },
+) {
+  const createFedGraphResponse = await client.platform.createFederatedGraph(
+    {
+      name: options.name,
+      namespace: options.namespace,
+      routingUrl: options.routingUrl.toString(),
+      labelMatchers: [options.labelMatcher],
+    },
+    {
+      headers: getBaseHeaders(),
+    },
+  );
+
+  switch (createFedGraphResponse.response?.code) {
+    case EnumStatusCode.OK: {
+      return { error: null };
+    }
+    default: {
+      return {
+        error: new Error(createFedGraphResponse.response?.details ?? 'An unknown error occured'),
+      };
+    }
+  }
+}
+
+async function handleGetFederatedGraphResponse(
+  client: BaseCommandOptions['client'],
+  {
+    onboarding,
+    userInfo,
+  }: {
+    onboarding: {
+      finishedAt?: string;
+    };
+    userInfo: UserInfo;
+  },
+) {
+  function retryFn() {
+    resetScreen(userInfo);
+    return handleGetFederatedGraphResponse(client, {
+      onboarding,
+      userInfo,
+    });
+  }
+
+  const spinner = ora().start();
+  const getFederatedGraphResponse = await fetchFederatedGraphByName(client, {
+    name: DEMO_GRAPH_NAME,
+    namespace: DEMO_NAMESPACES,
+  });
+
+  if (getFederatedGraphResponse.error) {
+    spinner.fail(`Failed to retrieve graph information ${getFederatedGraphResponse.error}`);
+    await waitForKeyPress(
+      {
+        r: retryFn,
+        R: retryFn,
+      },
+      'Hit [r] to refresh. CTRL+C to quit',
+    );
+    return;
+  }
+
+  if (getFederatedGraphResponse.data?.graph) {
+    spinner.succeed(`Federated graph ${pc.bold(getFederatedGraphResponse.data?.graph?.name)} exists.`);
+  } else {
+    spinner.stop();
+  }
+
+  return getFederatedGraphResponse.data;
+}
+
+async function cleanupFederatedGraph(
+  client: BaseCommandOptions['client'],
+  {
+    graphData,
+    userInfo,
+  }: {
+    graphData: {
+      graph: FederatedGraph;
+      subgraphs: Subgraph[];
+    };
+    userInfo: UserInfo;
+  },
+) {
+  function retryFn() {
+    resetScreen(userInfo);
+    cleanupFederatedGraph(client, { graphData, userInfo });
+  }
+
+  const spinner = ora().start(`Removing federated graph ${pc.bold(graphData.graph.name)}…`);
+  const deleteResponse = await cleanUpFederatedGraph(client, graphData);
+
+  if (deleteResponse.error) {
+    spinner.fail(`Removing federated graph ${graphData.graph.name} failed.`);
+    console.error(deleteResponse.error.message);
+
+    await waitForKeyPress(
+      {
+        Enter: () => undefined,
+        r: retryFn,
+        R: retryFn,
+      },
+      `Failed to delete the federated graph ${pc.bold(graphData.graph.name)}. [ENTER] to continue, [r] to retry. CTRL+C to quit.`,
+    );
+  }
+
+  spinner.succeed(`Federated graph ${pc.bold(graphData.graph.name)} removed.`);
+}
+
+async function handleCreateFederatedGraphResponse(
+  client: BaseCommandOptions['client'],
+  {
+    onboarding,
+    userInfo,
+  }: {
+    onboarding: {
+      finishedAt?: string;
+    };
+    userInfo: UserInfo;
+  },
+) {
+  function retryFn() {
+    resetScreen(userInfo);
+    handleCreateFederatedGraphResponse(client, { onboarding, userInfo });
+  }
+
+  const routingUrl = new URL('http://localhost');
+  routingUrl.port = String(DEMO_ROUTER_PORT);
+
+  const federatedGraphSpinner = ora().start();
+  const createGraphResponse = await createFederatedGraph(client, {
+    name: DEMO_GRAPH_NAME,
+    namespace: DEMO_NAMESPACES,
+    labelMatcher: DEMO_LABEL_MATCHER,
+    routingUrl,
+  });
+
+  if (createGraphResponse.error) {
+    federatedGraphSpinner.fail(createGraphResponse.error.message);
+
+    await waitForKeyPress(
+      {
+        r: retryFn,
+        R: retryFn,
+      },
+      'Hit [r] to refresh. CTRL+C to quit',
+    );
+    return;
+  }
+
+  federatedGraphSpinner.succeed(`Federated graph ${pc.bold('demo')} succesfully created.`);
+}
+
+async function handleStep2(
+  opts: BaseCommandOptions,
+  {
+    onboarding,
+    userInfo,
+  }: {
+    onboarding: {
+      finishedAt?: string;
+    };
+    userInfo: UserInfo;
+  },
+) {
+  const graphData = await handleGetFederatedGraphResponse(opts.client, {
+    onboarding,
+    userInfo,
+  });
+
+  const graph = graphData?.graph;
+  const subgraphs = graphData?.subgraphs ?? [];
+  if (graph) {
+    const cleanupFn = async () =>
+      await cleanupFederatedGraph(opts.client, {
+        graphData: { graph, subgraphs },
+        userInfo,
+      });
+    await waitForKeyPress(
+      {
+        Enter: () => undefined,
+        d: cleanupFn,
+        D: cleanupFn,
+      },
+      'Hit [ENTER] to continue or [d] to delete the federated graph and its subgraphs to start over. CTRL+C to quit.',
+    );
+    return;
+  }
+
+  await handleCreateFederatedGraphResponse(opts.client, {
+    onboarding,
+    userInfo,
+  });
+}
+
 async function checkExistingOnboarding(client: BaseCommandOptions['client']) {
   const { response, finishedAt, enabled } = await client.platform.getOnboarding(
     {},
@@ -148,7 +444,7 @@ async function handleGetOnboardingResponse(client: BaseCommandOptions['client'],
 }
 
 async function handleStep1(opts: BaseCommandOptions, userInfo: UserInfo) {
-  await handleGetOnboardingResponse(opts.client, userInfo);
+  return await handleGetOnboardingResponse(opts.client, userInfo);
 }
 
 async function fetchUserInfo(client: BaseCommandOptions['client']) {
@@ -267,6 +563,12 @@ export default function (opts: BaseCommandOptions) {
     const userInfo = await getUserInfo(opts.client);
     resetScreen(userInfo);
 
-    await handleStep1(opts, userInfo);
+    const onboardingCheck = await handleStep1(opts, userInfo);
+
+    if (!onboardingCheck) {
+      return;
+    }
+
+    await handleStep2(opts, { onboarding: onboardingCheck, userInfo });
   };
 }