feat: add support for plugins

.github/workflows/controlplane-ci.yaml

@@ -70,7 +70,7 @@ jobs:
         run: git diff --no-ext-diff --exit-code
 
       - name: Build
-        run: pnpm run --filter ./controlplane --filter ./connect --filter ./shared --filter ./composition build
+        run: pnpm run --filter ./controlplane --filter ./connect --filter ./shared --filter ./composition --filter ./protographic build
 
       - uses: actions/setup-java@v4
         with:

.gitignore

@@ -21,3 +21,6 @@ lerna-debug.log
 # Go workspace files
 go.work
 go.work.sum
+
+# Mise local config
+**/mise.local.toml

cli/.env.example

@@ -1,6 +1,7 @@
 COSMO_API_KEY=cosmo_669b576aaadc10ee1ae81d9193425705
 COSMO_API_URL=http://localhost:3001
 CDN_URL=http://localhost:11000
+PLUGIN_REGISTRY_URL=
 
 # configure running wgc behind a proxy
 # HTTPS_PROXY=""

cli/src/commands/feature-subgraph/commands/create.ts

@@ -6,6 +6,7 @@ import { Command, program } from 'commander';
 import ora from 'ora';
 import { resolve } from 'pathe';
 import pc from 'picocolors';
+import { SubgraphType } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb';
 import { getBaseHeaders } from '../../../core/config.js';
 import { BaseCommandOptions } from '../../../core/types/types.js';
 import { validateSubscriptionProtocols } from '../../../utils.js';
@@ -16,7 +17,7 @@ export default (opts: BaseCommandOptions) => {
   command.description('Creates a feature subgraph on the control plane.');
   command.argument('<name>', 'The name of the feature subgraph to create.');
   command.option('-n, --namespace [string]', 'The namespace of the feature subgraph.');
-  command.requiredOption(
+  command.option(
     '-r, --routing-url <url>',
     'The routing url of your feature subgraph. This is the url at which the feature subgraph will be accessible.',
   );

cli/src/commands/feature-subgraph/commands/publish.ts

@@ -1,15 +1,15 @@
-import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { SubgraphType } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb';
+import { parseGraphQLSubscriptionProtocol, parseGraphQLWebsocketSubprotocol } from '@wundergraph/cosmo-shared';
 import { Command, program } from 'commander';
 import ora from 'ora';
 import { resolve } from 'pathe';
 import pc from 'picocolors';
-import { parseGraphQLSubscriptionProtocol, parseGraphQLWebsocketSubprotocol } from '@wundergraph/cosmo-shared';
-import { BaseCommandOptions } from '../../../core/types/types.js';
-import { getBaseHeaders } from '../../../core/config.js';
-import { validateSubscriptionProtocols } from '../../../utils.js';
 import { websocketSubprotocolDescription } from '../../../constants.js';
+import { BaseCommandOptions } from '../../../core/types/types.js';
 import { handleCompositionResult } from '../../../handle-composition-result.js';
+import { validateSubscriptionProtocols } from '../../../utils.js';
 
 export default (opts: BaseCommandOptions) => {
   const command = new Command('publish');
@@ -94,30 +94,27 @@ export default (opts: BaseCommandOptions) => {
       spinner.start();
     }
 
-    const resp = await opts.client.platform.publishFederatedSubgraph(
-      {
-        baseSubgraphName: options.subgraph,
-        disableResolvabilityValidation: options.disableResolvabilityValidation,
-        isFeatureSubgraph: true,
-        labels: [],
-        name,
-        namespace: options.namespace,
-        // Publish schema only
-        // Optional when feature subgraph does not exist yet
-        routingUrl: options.routingUrl,
-        schema,
-        subscriptionProtocol: options.subscriptionProtocol
-          ? parseGraphQLSubscriptionProtocol(options.subscriptionProtocol)
-          : undefined,
-        subscriptionUrl: options.subscriptionUrl,
-        websocketSubprotocol: options.websocketSubprotocol
-          ? parseGraphQLWebsocketSubprotocol(options.websocketSubprotocol)
-          : undefined,
-      },
-      {
-        headers: getBaseHeaders(),
-      },
-    );
+    const resp = await opts.client.platform.publishFederatedSubgraph({
+      baseSubgraphName: options.subgraph,
+      disableResolvabilityValidation: options.disableResolvabilityValidation,
+      isFeatureSubgraph: true,
+      labels: [],
+      name,
+      namespace: options.namespace,
+      // Publish schema only
+      // Optional when feature subgraph does not exist yet
+      routingUrl: options.routingUrl,
+      schema,
+      subscriptionProtocol: options.subscriptionProtocol
+        ? parseGraphQLSubscriptionProtocol(options.subscriptionProtocol)
+        : undefined,
+      subscriptionUrl: options.subscriptionUrl,
+      websocketSubprotocol: options.websocketSubprotocol
+        ? parseGraphQLWebsocketSubprotocol(options.websocketSubprotocol)
+        : undefined,
+      // passing Standard type to the backend, because the users have to use the 'wgc router plugin publish' command to publish the plugin
+      type: SubgraphType.STANDARD,
+    });
 
     try {
       handleCompositionResult({

cli/src/commands/router/commands/plugin/commands/create.ts

@@ -0,0 +1,69 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { EnumStatusCode } from '@wundergraph/cosmo-connect/dist/common/common_pb';
+import { SubgraphType } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb';
+import { splitLabel } from '@wundergraph/cosmo-shared';
+import { Command, program } from 'commander';
+import ora from 'ora';
+import { resolve } from 'pathe';
+import pc from 'picocolors';
+import { getBaseHeaders } from '../../../../../core/config.js';
+import { BaseCommandOptions } from '../../../../../core/types/types.js';
+
+export default (opts: BaseCommandOptions) => {
+  const command = new Command('create');
+  command.description('Creates a federated plugin subgraph on the control plane.');
+  command.argument(
+    '<name>',
+    'The name of the plugin subgraph to create. It is usually in the format of <org>.<service.name> and is used to uniquely identify your plugin subgraph.',
+  );
+  command.option('-n, --namespace [string]', 'The namespace of the plugin subgraph.');
+  command.option(
+    '--label [labels...]',
+    'The labels to apply to the subgraph. The labels are passed in the format <key>=<value> <key>=<value>.',
+  );
+  command.option('--readme <path-to-readme>', 'The markdown file which describes the subgraph.');
+
+  command.action(async (name, options) => {
+    let readmeFile;
+    if (options.readme) {
+      readmeFile = resolve(options.readme);
+      if (!existsSync(readmeFile)) {
+        program.error(
+          pc.red(
+            pc.bold(`The readme file '${pc.bold(readmeFile)}' does not exist. Please check the path and try again.`),
+          ),
+        );
+      }
+    }
+
+    const spinner = ora('Plugin Subgraph is being created...').start();
+    const resp = await opts.client.platform.createFederatedSubgraph(
+      {
+        name,
+        namespace: options.namespace,
+        labels: options.label ? options.label.map((label: string) => splitLabel(label)) : [],
+        routingUrl: '',
+        readme: readmeFile ? await readFile(readmeFile, 'utf8') : undefined,
+        type: SubgraphType.GRPC_PLUGIN,
+      },
+      {
+        headers: getBaseHeaders(),
+      },
+    );
+
+    if (resp.response?.code === EnumStatusCode.OK) {
+      spinner.succeed('Plugin Subgraph was created successfully.');
+    } else {
+      spinner.fail('Failed to create pluginsubgraph.');
+      if (resp.response?.details) {
+        console.log(pc.red(pc.bold(resp.response?.details)));
+      }
+      process.exitCode = 1;
+      // eslint-disable-next-line no-useless-return
+      return;
+    }
+  });
+
+  return command;
+};

cli/src/commands/router/commands/plugin/commands/delete.ts

@@ -0,0 +1,156 @@
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { EnumStatusCode } from '@wundergraph/cosmo-connect/dist/common/common_pb';
+import inquirer from 'inquirer';
+import Table from 'cli-table3';
+import ora from 'ora';
+import { BaseCommandOptions } from '../../../../../core/types/types.js';
+import { getBaseHeaders } from '../../../../../core/config.js';
+
+export default (opts: BaseCommandOptions) => {
+  const command = new Command('delete');
+  command.description('Deletes a plugin subgraph on the control plane.');
+  command.argument('<name>', 'The name of the plugin subgraph to delete.');
+  command.option('-n, --namespace [string]', 'The namespace of the plugin subgraph.');
+  command.option('-f --force', 'Flag to force the deletion (skip confirmation).');
+  command.option('--suppress-warnings', 'This flag suppresses any warnings produced by composition.');
+  command.action(async (name, options) => {
+    if (!options.force) {
+      const deletionConfirmed = await inquirer.prompt({
+        name: 'confirmDeletion',
+        type: 'confirm',
+        message: `Are you sure you want to delete the plugin subgraph "${name}"?`,
+      });
+      if (!deletionConfirmed.confirmDeletion) {
+        process.exitCode = 1;
+        return;
+      }
+    }
+
+    const spinner = ora(`The plugin subgraph "${name}" is being deleted...`).start();
+
+    const resp = await opts.client.platform.deleteFederatedSubgraph(
+      {
+        subgraphName: name,
+        namespace: options.namespace,
+      },
+      {
+        headers: getBaseHeaders(),
+      },
+    );
+
+    switch (resp.response?.code) {
+      case EnumStatusCode.OK: {
+        spinner.succeed(`The plugin subgraph "${name}" was deleted successfully.`);
+        if (resp.proposalMatchMessage) {
+          console.log(pc.yellow(`Warning: Proposal match failed`));
+          console.log(pc.yellow(resp.proposalMatchMessage));
+        }
+        break;
+      }
+      case EnumStatusCode.ERR_SCHEMA_MISMATCH_WITH_APPROVED_PROPOSAL: {
+        spinner.fail(`Failed to delete plugin subgraph "${name}".`);
+        console.log(pc.red(`Error: Proposal match failed`));
+        console.log(pc.red(resp.proposalMatchMessage));
+        break;
+      }
+      case EnumStatusCode.ERR_SUBGRAPH_COMPOSITION_FAILED: {
+        spinner.fail(`The plugin subgraph "${name}" was deleted but with composition errors.`);
+
+        const compositionErrorsTable = new Table({
+          head: [
+            pc.bold(pc.white('FEDERATED_GRAPH_NAME')),
+            pc.bold(pc.white('NAMESPACE')),
+            pc.bold(pc.white('FEATURE_FLAG')),
+            pc.bold(pc.white('ERROR_MESSAGE')),
+          ],
+          colWidths: [30, 30, 30, 120],
+          wordWrap: true,
+        });
+
+        console.log(
+          pc.red(
+            `There were composition errors when composing at least one federated graph related to the` +
+              ` plugin subgraph "${name}".\nThe router will continue to work with the latest valid schema.` +
+              `\n${pc.bold('Please check the errors below:')}`,
+          ),
+        );
+        for (const compositionError of resp.compositionErrors) {
+          compositionErrorsTable.push([
+            compositionError.federatedGraphName,
+            compositionError.namespace,
+            compositionError.featureFlag || '-',
+            compositionError.message,
+          ]);
+        }
+        // Don't exit here with 1 because the change was still applied
+        console.log(compositionErrorsTable.toString());
+
+        break;
+      }
+      case EnumStatusCode.ERR_DEPLOYMENT_FAILED: {
+        spinner.warn(
+          `The plugin subgraph "${name}" was deleted, but the updated composition could not be deployed.` +
+            `\nThis means the updated composition is not accessible to the router.` +
+            `\n${pc.bold('Please check the errors below:')}`,
+        );
+
+        const deploymentErrorsTable = new Table({
+          head: [
+            pc.bold(pc.white('FEDERATED_GRAPH_NAME')),
+            pc.bold(pc.white('NAMESPACE')),
+            pc.bold(pc.white('ERROR_MESSAGE')),
+          ],
+          colWidths: [30, 30, 120],
+          wordWrap: true,
+        });
+
+        for (const deploymentError of resp.deploymentErrors) {
+          deploymentErrorsTable.push([
+            deploymentError.federatedGraphName,
+            deploymentError.namespace,
+            deploymentError.message,
+          ]);
+        }
+        // Don't exit here with 1 because the change was still applied
+        console.log(deploymentErrorsTable.toString());
+
+        break;
+      }
+      default: {
+        spinner.fail(`Failed to delete the plugin subgraph "${name}".`);
+        if (resp.response?.details) {
+          console.log(pc.red(pc.bold(resp.response?.details)));
+        }
+        process.exitCode = 1;
+        return;
+      }
+    }
+
+    if (!options.suppressWarnings && resp.compositionWarnings.length > 0) {
+      const compositionWarningsTable = new Table({
+        head: [
+          pc.bold(pc.white('FEDERATED_GRAPH_NAME')),
+          pc.bold(pc.white('NAMESPACE')),
+          pc.bold(pc.white('FEATURE_FLAG')),
+          pc.bold(pc.white('WARNING_MESSAGE')),
+        ],
+        colWidths: [30, 30, 30, 120],
+        wordWrap: true,
+      });
+
+      console.log(pc.yellow(`The following warnings were produced while composing the federated graph:`));
+      for (const compositionWarning of resp.compositionWarnings) {
+        compositionWarningsTable.push([
+          compositionWarning.federatedGraphName,
+          compositionWarning.namespace,
+          compositionWarning.featureFlag || '-',
+          compositionWarning.message,
+        ]);
+      }
+      console.log(compositionWarningsTable.toString());
+    }
+  });
+
+  return command;
+};