feat(api7): add server-side configuration validator

apps/cli/src/command/index.ts

@@ -11,6 +11,7 @@ import { IngressSyncCommand } from './ingress-sync.command';
 import { LintCommand } from './lint.command';
 import { PingCommand } from './ping.command';
 import { SyncCommand } from './sync.command';
+import { ValidateCommand } from './validate.command';
 import { configurePluralize } from './utils';
 
 const versionCode = '0.24.3';
@@ -47,8 +48,8 @@ export const setupCommands = (): Command => {
     .addCommand(DiffCommand)
     .addCommand(SyncCommand)
     .addCommand(ConvertCommand)
-    .addCommand(LintCommand);
-  //.addCommand(ValidateCommand)
+    .addCommand(LintCommand)
+    .addCommand(ValidateCommand);
 
   if (process.env.NODE_ENV === 'development') program.addCommand(DevCommand);
 

apps/cli/src/command/validate.command.ts

@@ -0,0 +1,77 @@
+import { Listr } from 'listr2';
+
+import {
+  DiffResourceTask,
+  LintTask,
+  LoadLocalConfigurationTask,
+  ValidateTask,
+} from '../tasks';
+import { InitializeBackendTask } from '../tasks/init_backend';
+import { SignaleRenderer } from '../utils/listr';
+import { TaskContext } from './diff.command';
+import { BackendCommand, NoLintOption } from './helper';
+import { BackendOptions } from './typing';
+
+export type ValidateOptions = BackendOptions & {
+  file: Array<string>;
+  lint: boolean;
+};
+
+export const ValidateCommand = new BackendCommand<ValidateOptions>(
+  'validate',
+  'validate the local configuration against the backend',
+  'Validate the configuration from the local file(s) against the backend without applying any changes.',
+)
+  .option(
+    '-f, --file <file-path>',
+    'file to validate',
+    (filePath, files: Array<string> = []) => files.concat(filePath),
+  )
+  .addOption(NoLintOption)
+  .addExamples([
+    {
+      title: 'Validate configuration from a single file',
+      command: 'adc validate -f adc.yaml',
+    },
+    {
+      title: 'Validate configuration from multiple files',
+      command: 'adc validate -f service-a.yaml -f service-b.yaml',
+    },
+    {
+      title: 'Validate configuration against API7 EE backend',
+      command:
+        'adc validate -f adc.yaml --backend api7ee --gateway-group default',
+    },
+    {
+      title: 'Validate configuration without lint check',
+      command: 'adc validate -f adc.yaml --no-lint',
+    },
+  ])
+  .handle(async (opts) => {
+    const tasks = new Listr<TaskContext, typeof SignaleRenderer>(
+      [
+        InitializeBackendTask(opts.backend, opts),
+        LoadLocalConfigurationTask(
+          opts.file,
+          opts.labelSelector,
+          opts.includeResourceType,
+          opts.excludeResourceType,
+        ),
+        opts.lint ? LintTask() : { task: () => undefined },
+        DiffResourceTask(),
+        ValidateTask(),
+      ],
+      {
+        renderer: SignaleRenderer,
+        rendererOptions: { verbose: opts.verbose },
+        ctx: { remote: {}, local: {}, diff: [] },
+      },
+    );
+
+    try {
+      await tasks.run();
+    } catch (err) {
+      if (opts.verbose === 2) console.log(err);
+      process.exit(1);
+    }
+  });

apps/cli/src/tasks/index.ts

@@ -2,4 +2,5 @@ export * from './load_local';
 export * from './load_remote';
 export * from './diff';
 export * from './lint';
+export * from './validate';
 export * from './experimental';

apps/cli/src/tasks/validate.ts

@@ -0,0 +1,48 @@
+import * as ADCSDK from '@api7/adc-sdk';
+import { ListrTask } from 'listr2';
+import { lastValueFrom } from 'rxjs';
+
+export const ValidateTask = (): ListrTask<{
+  backend: ADCSDK.Backend;
+  diff: ADCSDK.Event[];
+}> => ({
+  title: 'Validate configuration against backend',
+  task: async (ctx) => {
+    if (!ctx.backend.supportValidate) {
+      throw new Error(
+        'Validate is not supported by the current backend',
+      );
+    }
+
+    const supported = await ctx.backend.supportValidate();
+    if (!supported) {
+      const version = await ctx.backend.version();
+      throw new Error(
+        `Validate is not supported by the current backend version (${version}). Please upgrade to a newer version.`,
+      );
+    }
+
+    const result = await lastValueFrom(ctx.backend.validate!(ctx.diff));
+    if (!result.success) {
+      const lines: string[] = [];
+      if (result.errorMessage) {
+        lines.push(result.errorMessage);
+      }
+      for (const e of result.errors) {
+        const parts: string[] = [e.resource_type];
+        if (e.resource_name) {
+          parts.push(`name="${e.resource_name}"`);
+        } else {
+          if (e.resource_id) parts.push(`id="${e.resource_id}"`);
+          if (e.index !== undefined) parts.push(`index=${e.index}`);
+        }
+        lines.push(`  - [${parts.join(', ')}]: ${e.error}`);
+      }
+      const error = new Error(
+        `Configuration validation failed:\n${lines.join('\n')}`,
+      );
+      error.stack = '';
+      throw error;
+    }
+  },
+});