From 14b17165dc89d480e0b6d0fca95bbdd734359ec8 Mon Sep 17 00:00:00 2001 From: Alessandro Pagnin Date: Mon, 17 Aug 2026 10:38:56 +0200 Subject: [PATCH 1/4] feat: add proposal status command --- cli/src/commands/proposal/commands/status.ts | 135 ++++++++++++++ cli/src/commands/proposal/index.ts | 2 + cli/test/proposal-status.test.ts | 181 +++++++++++++++++++ docs-website/cli/proposal.mdx | 4 + docs-website/cli/proposal/status.mdx | 51 ++++++ docs-website/docs.json | 2 +- 6 files changed, 374 insertions(+), 1 deletion(-) create mode 100644 cli/src/commands/proposal/commands/status.ts create mode 100644 cli/test/proposal-status.test.ts create mode 100644 docs-website/cli/proposal/status.mdx diff --git a/cli/src/commands/proposal/commands/status.ts b/cli/src/commands/proposal/commands/status.ts new file mode 100644 index 0000000000..09f46e84eb --- /dev/null +++ b/cli/src/commands/proposal/commands/status.ts @@ -0,0 +1,135 @@ +import { EnumStatusCode } from '@wundergraph/cosmo-connect/dist/common/common_pb'; +import type { Proposal } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb'; +import { Command } from 'commander'; +import pc from 'picocolors'; +import { getBaseHeaders } from '../../../core/config.js'; +import { BaseCommandOptions } from '../../../core/types/types.js'; + +const PROPOSALS_PAGE_SIZE = 50; + +type FindProposalResult = { success: true; proposal: Proposal } | { success: false; details: string }; + +const findProposal = async ( + client: BaseCommandOptions['client'], + { + name, + federatedGraphName, + namespace, + checkAllProposals, + }: { + name: string; + federatedGraphName: string; + namespace?: string; + checkAllProposals: boolean; + }, +): Promise => { + let offset = 0; + + do { + const resp = await client.platform.getProposalsByFederatedGraph( + { + federatedGraphName, + namespace, + limit: PROPOSALS_PAGE_SIZE, + offset, + }, + { + headers: getBaseHeaders(), + }, + ); + + if (resp.response?.code !== EnumStatusCode.OK) { + return { + success: false, + details: resp.response?.details || `Failed to fetch proposal '${name}'.`, + }; + } + + const proposal = resp.proposals.find((item) => item.name === name); + if (proposal) { + return { success: true, proposal }; + } + + if (!checkAllProposals) { + break; + } + + if (resp.proposals.length === 0) { + break; + } + + offset += resp.proposals.length; + if (offset >= resp.totalCount) { + break; + } + } while (true); + + return { + success: false, + details: `Proposal '${name}' not found.`, + }; +}; + +export default (opts: BaseCommandOptions) => { + const command = new Command('status'); + command.description( + 'Checks the status of an existing proposal for a federated graph. By default, only the 50 most recent proposals are checked. Checking all proposals can be slow.', + ); + command.argument('', 'The name of the proposal to check.'); + command.requiredOption( + '-f, --federation-graph ', + 'The name of the federated graph this proposal is for.', + ); + command.option('-n, --namespace [string]', 'The namespace of the federated graph.'); + command.option('-j, --json', 'Prints to the console in json format instead of text.'); + command.option( + '--check-all-proposals', + 'Checks all proposals instead of only the 50 most recent proposals. This can be slow.', + ); + + command.action(async (name, options) => { + let result: FindProposalResult; + + try { + result = await findProposal(opts.client, { + name, + federatedGraphName: options.federationGraph, + namespace: options.namespace, + checkAllProposals: options.checkAllProposals, + }); + } catch (error) { + result = { + success: false, + details: error instanceof Error ? error.message : 'An unknown error occurred.', + }; + } + + if (!result.success) { + if (options.json) { + console.log( + JSON.stringify({ + status: 'error', + details: result.details, + }), + ); + } else { + console.error(pc.red(result.details)); + } + process.exitCode = 1; + return; + } + + if (options.json) { + console.log( + JSON.stringify({ + status: result.proposal.state, + }), + ); + return; + } + + console.log(`Proposal '${name}' status is ${pc.bold(result.proposal.state)}.`); + }); + + return command; +}; diff --git a/cli/src/commands/proposal/index.ts b/cli/src/commands/proposal/index.ts index 0483103bad..f8183b116e 100644 --- a/cli/src/commands/proposal/index.ts +++ b/cli/src/commands/proposal/index.ts @@ -2,6 +2,7 @@ import { Command } from 'commander'; import { BaseCommandOptions } from '../../core/types/types.js'; import { checkAuth } from '../auth/utils.js'; import CreateProposalCommand from './commands/create.js'; +import StatusProposalCommand from './commands/status.js'; import UpdateProposalCommand from './commands/update.js'; export default (opts: BaseCommandOptions) => { @@ -9,6 +10,7 @@ export default (opts: BaseCommandOptions) => { command.description('Provides commands for creating and maintaining proposals for a federated graph'); command.addCommand(CreateProposalCommand(opts)); command.addCommand(UpdateProposalCommand(opts)); + command.addCommand(StatusProposalCommand(opts)); command.hook('preAction', async (thisCmd) => { await checkAuth(); diff --git a/cli/test/proposal-status.test.ts b/cli/test/proposal-status.test.ts new file mode 100644 index 0000000000..1e9286ab02 --- /dev/null +++ b/cli/test/proposal-status.test.ts @@ -0,0 +1,181 @@ +import { type MessageInitShape } from '@bufbuild/protobuf'; +import { createClient, createRouterTransport } from '@connectrpc/connect'; +import { EnumStatusCode } from '@wundergraph/cosmo-connect/dist/common/common_pb'; +import { + type GetProposalsByFederatedGraphRequest, + GetProposalsByFederatedGraphResponseSchema, + PlatformService, +} from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb'; +import { Command } from 'commander'; +import { afterEach, beforeEach, describe, expect, test, vi, type MockInstance } from 'vitest'; +import StatusProposalCommand from '../src/commands/proposal/commands/status.js'; +import { Client } from '../src/core/client/client.js'; + +type GetProposalsResponse = MessageInitShape; + +function createMockTransport( + response: GetProposalsResponse | ((req: GetProposalsByFederatedGraphRequest) => GetProposalsResponse), + onGetProposals?: (req: GetProposalsByFederatedGraphRequest) => void, +) { + return createRouterTransport(({ service }) => { + service(PlatformService, { + getProposalsByFederatedGraph: (req) => { + onGetProposals?.(req); + return typeof response === 'function' ? response(req) : response; + }, + }); + }); +} + +async function runStatus( + response: GetProposalsResponse | ((req: GetProposalsByFederatedGraphRequest) => GetProposalsResponse), + args: string[] = [], + onGetProposals?: (req: GetProposalsByFederatedGraphRequest) => void, +): Promise { + const client: Client = { + platform: createClient(PlatformService, createMockTransport(response, onGetProposals)), + }; + const program = new Command(); + program.exitOverride(); + program.addCommand(StatusProposalCommand({ client })); + await program.parseAsync(['status', 'my-proposal', '--federation-graph', 'my-graph', ...args], { from: 'user' }); +} + +describe('proposal status', () => { + let logSpy: MockInstance; + let errorSpy: MockInstance; + + beforeEach(() => { + logSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); + errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + }); + + afterEach(() => { + process.exitCode = undefined; + vi.restoreAllMocks(); + }); + + test('prints the proposal status as text', async () => { + let request: GetProposalsByFederatedGraphRequest | undefined; + + await runStatus( + { + response: { code: EnumStatusCode.OK }, + proposals: [{ name: 'my-proposal', state: 'DRAFT' }], + totalCount: 1, + }, + ['--namespace', 'production'], + (req) => { + request = req; + }, + ); + + expect(request).toMatchObject({ + federatedGraphName: 'my-graph', + namespace: 'production', + limit: 50, + offset: 0, + }); + expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Proposal 'my-proposal' status is DRAFT.")); + expect(errorSpy).not.toHaveBeenCalled(); + expect(process.exitCode).toBeUndefined(); + }); + + test('prints the proposal status as json', async () => { + await runStatus( + { + response: { code: EnumStatusCode.OK }, + proposals: [{ name: 'my-proposal', state: 'APPROVED' }], + totalCount: 1, + }, + ['--json'], + ); + + expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ status: 'APPROVED' })); + expect(errorSpy).not.toHaveBeenCalled(); + expect(process.exitCode).toBeUndefined(); + }); + + test('only checks the 50 most recent proposals by default', async () => { + let requestCount = 0; + + await runStatus( + { + response: { code: EnumStatusCode.OK }, + proposals: [{ name: 'another-proposal', state: 'DRAFT' }], + totalCount: 51, + }, + ['--json'], + () => { + requestCount++; + }, + ); + + expect(requestCount).toBe(1); + expect(process.exitCode).toBe(1); + }); + + test('checks subsequent pages when --check-all-proposals is set', async () => { + const requestedOffsets: number[] = []; + + await runStatus( + (req) => { + if (req.offset === 0) { + return { + response: { code: EnumStatusCode.OK }, + proposals: [{ name: 'another-proposal', state: 'DRAFT' }], + totalCount: 2, + }; + } + + return { + response: { code: EnumStatusCode.OK }, + proposals: [{ name: 'my-proposal', state: 'CLOSED' }], + totalCount: 2, + }; + }, + ['--check-all-proposals', '--json'], + (req) => { + requestedOffsets.push(req.offset); + }, + ); + + expect(requestedOffsets).toEqual([0, 1]); + expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ status: 'CLOSED' })); + expect(errorSpy).not.toHaveBeenCalled(); + expect(process.exitCode).toBeUndefined(); + }); + + test('prints a json error and sets a non-zero exit code when the proposal is not found', async () => { + await runStatus( + { + response: { code: EnumStatusCode.OK }, + proposals: [], + totalCount: 0, + }, + ['--json'], + ); + + expect(JSON.parse(String(logSpy.mock.calls[0][0]))).toEqual({ + status: 'error', + details: "Proposal 'my-proposal' not found.", + }); + expect(errorSpy).not.toHaveBeenCalled(); + expect(process.exitCode).toBe(1); + }); + + test('prints the control-plane error and sets a non-zero exit code', async () => { + await runStatus({ + response: { + code: EnumStatusCode.ERR_NOT_FOUND, + details: 'Federated graph my-graph not found', + }, + proposals: [], + totalCount: 0, + }); + + expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Federated graph my-graph not found')); + expect(logSpy).not.toHaveBeenCalled(); + expect(process.exitCode).toBe(1); + }); +}); diff --git a/docs-website/cli/proposal.mdx b/docs-website/cli/proposal.mdx index 2d9b3ed15a..3684a447c5 100644 --- a/docs-website/cli/proposal.mdx +++ b/docs-website/cli/proposal.mdx @@ -14,3 +14,7 @@ The `proposal` command and its subcommands provide functionality to manage propo Update an existing proposal for a federated graph + + + Check the status of an existing proposal for a federated graph + diff --git a/docs-website/cli/proposal/status.mdx b/docs-website/cli/proposal/status.mdx new file mode 100644 index 0000000000..1fca55f497 --- /dev/null +++ b/docs-website/cli/proposal/status.mdx @@ -0,0 +1,51 @@ +--- +title: 'Status' +description: 'Checks the status of an existing proposal for a federated graph.' +icon: magnifying-glass +--- + +## Usage + +```bash +npx wgc proposal status --federation-graph [options] +``` + +## Description + +The `npx wgc proposal status` command checks the current status of a proposal. By default, the command searches only the 50 most recent proposals for the federated graph. + +Use `--check-all-proposals` to continue searching through all available proposal pages. Checking all proposals can be slow when the federated graph has many proposals. + +## **Parameters** + +- `[name]`: The name of the proposal whose status you want to check. + +## **Options** + +- `-f, --federation-graph ` (required): The name of the federated graph this proposal is for. + +- `-n, --namespace [namespace]`: The namespace of the federated graph (Default: "default"). + +- `-j, --json`: Print the result in JSON format instead of text. + +- `--check-all-proposals`: Search all proposal pages instead of only the 50 most recent proposals. This can be slow. + +## **Examples** + +### Check the 50 most recent proposals + +```bash +npx wgc proposal status product-changes --federation-graph my-graph +``` + +### Check all proposals + +```bash +npx wgc proposal status product-changes --federation-graph my-graph --check-all-proposals +``` + +### Print JSON output + +```bash +npx wgc proposal status product-changes --federation-graph my-graph --json +``` diff --git a/docs-website/docs.json b/docs-website/docs.json index 1f73eed1ab..a2f6e9b881 100644 --- a/docs-website/docs.json +++ b/docs-website/docs.json @@ -672,7 +672,7 @@ { "group": "Proposal", "icon": "file-circle-plus", - "pages": ["cli/proposal", "cli/proposal/create", "cli/proposal/update"] + "pages": ["cli/proposal", "cli/proposal/create", "cli/proposal/update", "cli/proposal/status"] } ] } From f7b717e68e10510521cfbaddab5f561866f652f7 Mon Sep 17 00:00:00 2001 From: Alessandro Pagnin Date: Mon, 17 Aug 2026 11:25:14 +0200 Subject: [PATCH 2/4] fix: if not specified, use the default namespace --- cli/src/commands/proposal/commands/status.ts | 2 +- cli/test/proposal-status.test.ts | 18 ++++++++++++++++++ 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/cli/src/commands/proposal/commands/status.ts b/cli/src/commands/proposal/commands/status.ts index 09f46e84eb..15d59a35b9 100644 --- a/cli/src/commands/proposal/commands/status.ts +++ b/cli/src/commands/proposal/commands/status.ts @@ -80,7 +80,7 @@ export default (opts: BaseCommandOptions) => { '-f, --federation-graph ', 'The name of the federated graph this proposal is for.', ); - command.option('-n, --namespace [string]', 'The namespace of the federated graph.'); + command.option('-n, --namespace [string]', 'The namespace of the federated graph.', 'default'); command.option('-j, --json', 'Prints to the console in json format instead of text.'); command.option( '--check-all-proposals', diff --git a/cli/test/proposal-status.test.ts b/cli/test/proposal-status.test.ts index 1e9286ab02..36b81a7bd4 100644 --- a/cli/test/proposal-status.test.ts +++ b/cli/test/proposal-status.test.ts @@ -96,6 +96,24 @@ describe('proposal status', () => { expect(process.exitCode).toBeUndefined(); }); + test('uses the default namespace when none is specified', async () => { + let request: GetProposalsByFederatedGraphRequest | undefined; + + await runStatus( + { + response: { code: EnumStatusCode.OK }, + proposals: [{ name: 'my-proposal', state: 'DRAFT' }], + totalCount: 1, + }, + [], + (req) => { + request = req; + }, + ); + + expect(request?.namespace).toBe('default'); + }); + test('only checks the 50 most recent proposals by default', async () => { let requestCount = 0; From 90e69512afa5dc236aa9762bc020a340086f91d6 Mon Sep 17 00:00:00 2001 From: Alessandro Pagnin Date: Mon, 17 Aug 2026 12:06:42 +0200 Subject: [PATCH 3/4] fix: remove bold formatting --- cli/src/commands/proposal/commands/status.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/src/commands/proposal/commands/status.ts b/cli/src/commands/proposal/commands/status.ts index 15d59a35b9..75ffaa5934 100644 --- a/cli/src/commands/proposal/commands/status.ts +++ b/cli/src/commands/proposal/commands/status.ts @@ -128,7 +128,7 @@ export default (opts: BaseCommandOptions) => { return; } - console.log(`Proposal '${name}' status is ${pc.bold(result.proposal.state)}.`); + console.log(`Proposal '${name}' status is ${result.proposal.state}.`); }); return command; From d2dc1cde33697aad8223f6a43ffac35061b86d29 Mon Sep 17 00:00:00 2001 From: Alessandro Pagnin Date: Tue, 18 Aug 2026 21:23:17 +0200 Subject: [PATCH 4/4] feat: add filter by proposal name --- cli/src/commands/proposal/commands/status.ts | 71 ++++++------------- cli/src/commands/proposal/utils.ts | 37 ++++++++++ cli/test/proposal-status.test.ts | 59 ++------------- .../proto/wg/cosmo/platform/v1/platform.pb.go | 15 +++- .../src/wg/cosmo/platform/v1/platform_pb.ts | 7 +- .../proposal/getProposalsByFederatedGraph.ts | 2 + .../core/repositories/ProposalRepository.ts | 12 ++++ .../proposal/proposal-data-isolation.test.ts | 24 +++++++ docs-website/cli/proposal/status.mdx | 14 +--- proto/wg/cosmo/platform/v1/platform.proto | 1 + 10 files changed, 122 insertions(+), 120 deletions(-) diff --git a/cli/src/commands/proposal/commands/status.ts b/cli/src/commands/proposal/commands/status.ts index 75ffaa5934..2da68bcad2 100644 --- a/cli/src/commands/proposal/commands/status.ts +++ b/cli/src/commands/proposal/commands/status.ts @@ -2,10 +2,8 @@ import { EnumStatusCode } from '@wundergraph/cosmo-connect/dist/common/common_pb import type { Proposal } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb'; import { Command } from 'commander'; import pc from 'picocolors'; -import { getBaseHeaders } from '../../../core/config.js'; import { BaseCommandOptions } from '../../../core/types/types.js'; - -const PROPOSALS_PAGE_SIZE = 50; +import { getProposalsByFederatedGraph } from '../utils.js'; type FindProposalResult = { success: true; proposal: Proposal } | { success: false; details: string }; @@ -15,54 +13,32 @@ const findProposal = async ( name, federatedGraphName, namespace, - checkAllProposals, }: { name: string; federatedGraphName: string; namespace?: string; - checkAllProposals: boolean; }, ): Promise => { - let offset = 0; - - do { - const resp = await client.platform.getProposalsByFederatedGraph( - { - federatedGraphName, - namespace, - limit: PROPOSALS_PAGE_SIZE, - offset, - }, - { - headers: getBaseHeaders(), - }, - ); - - if (resp.response?.code !== EnumStatusCode.OK) { - return { - success: false, - details: resp.response?.details || `Failed to fetch proposal '${name}'.`, - }; - } - - const proposal = resp.proposals.find((item) => item.name === name); - if (proposal) { - return { success: true, proposal }; - } - - if (!checkAllProposals) { - break; - } + const resp = await getProposalsByFederatedGraph({ + client, + federatedGraphName, + namespace, + proposalName: name, + limit: 1, + offset: 0, + }); - if (resp.proposals.length === 0) { - break; - } + if (resp.response?.code !== EnumStatusCode.OK) { + return { + success: false, + details: resp.response?.details || `Failed to fetch proposal '${name}'.`, + }; + } - offset += resp.proposals.length; - if (offset >= resp.totalCount) { - break; - } - } while (true); + const proposal = resp.proposals.find((item) => item.name === name); + if (proposal) { + return { success: true, proposal }; + } return { success: false, @@ -72,9 +48,7 @@ const findProposal = async ( export default (opts: BaseCommandOptions) => { const command = new Command('status'); - command.description( - 'Checks the status of an existing proposal for a federated graph. By default, only the 50 most recent proposals are checked. Checking all proposals can be slow.', - ); + command.description('Checks the status of an existing proposal for a federated graph.'); command.argument('', 'The name of the proposal to check.'); command.requiredOption( '-f, --federation-graph ', @@ -82,10 +56,6 @@ export default (opts: BaseCommandOptions) => { ); command.option('-n, --namespace [string]', 'The namespace of the federated graph.', 'default'); command.option('-j, --json', 'Prints to the console in json format instead of text.'); - command.option( - '--check-all-proposals', - 'Checks all proposals instead of only the 50 most recent proposals. This can be slow.', - ); command.action(async (name, options) => { let result: FindProposalResult; @@ -95,7 +65,6 @@ export default (opts: BaseCommandOptions) => { name, federatedGraphName: options.federationGraph, namespace: options.namespace, - checkAllProposals: options.checkAllProposals, }); } catch (error) { result = { diff --git a/cli/src/commands/proposal/utils.ts b/cli/src/commands/proposal/utils.ts index 9dda2072a7..0275481f8c 100644 --- a/cli/src/commands/proposal/utils.ts +++ b/cli/src/commands/proposal/utils.ts @@ -7,6 +7,43 @@ import { resolve } from 'pathe'; import { LabelSchema } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb'; import type { Label } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb'; import { splitLabel } from '@wundergraph/cosmo-shared'; +import type { Client } from '../../core/client/client.js'; +import { getBaseHeaders } from '../../core/config.js'; + +export const getProposalsByFederatedGraph = ({ + client, + federatedGraphName, + namespace, + proposalName, + startDate, + endDate, + limit, + offset, +}: { + client: Client; + federatedGraphName: string; + namespace?: string; + proposalName?: string; + startDate?: string; + endDate?: string; + limit?: number; + offset?: number; +}) => { + return client.platform.getProposalsByFederatedGraph( + { + federatedGraphName, + namespace, + proposalName, + startDate, + endDate, + limit, + offset, + }, + { + headers: getBaseHeaders(), + }, + ); +}; // Define interfaces for parsing parameters interface SubgraphParams { diff --git a/cli/test/proposal-status.test.ts b/cli/test/proposal-status.test.ts index 36b81a7bd4..3ed0bb4e29 100644 --- a/cli/test/proposal-status.test.ts +++ b/cli/test/proposal-status.test.ts @@ -14,21 +14,21 @@ import { Client } from '../src/core/client/client.js'; type GetProposalsResponse = MessageInitShape; function createMockTransport( - response: GetProposalsResponse | ((req: GetProposalsByFederatedGraphRequest) => GetProposalsResponse), + response: GetProposalsResponse, onGetProposals?: (req: GetProposalsByFederatedGraphRequest) => void, ) { return createRouterTransport(({ service }) => { service(PlatformService, { getProposalsByFederatedGraph: (req) => { onGetProposals?.(req); - return typeof response === 'function' ? response(req) : response; + return response; }, }); }); } async function runStatus( - response: GetProposalsResponse | ((req: GetProposalsByFederatedGraphRequest) => GetProposalsResponse), + response: GetProposalsResponse, args: string[] = [], onGetProposals?: (req: GetProposalsByFederatedGraphRequest) => void, ): Promise { @@ -73,7 +73,8 @@ describe('proposal status', () => { expect(request).toMatchObject({ federatedGraphName: 'my-graph', namespace: 'production', - limit: 50, + proposalName: 'my-proposal', + limit: 1, offset: 0, }); expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Proposal 'my-proposal' status is DRAFT.")); @@ -114,56 +115,6 @@ describe('proposal status', () => { expect(request?.namespace).toBe('default'); }); - test('only checks the 50 most recent proposals by default', async () => { - let requestCount = 0; - - await runStatus( - { - response: { code: EnumStatusCode.OK }, - proposals: [{ name: 'another-proposal', state: 'DRAFT' }], - totalCount: 51, - }, - ['--json'], - () => { - requestCount++; - }, - ); - - expect(requestCount).toBe(1); - expect(process.exitCode).toBe(1); - }); - - test('checks subsequent pages when --check-all-proposals is set', async () => { - const requestedOffsets: number[] = []; - - await runStatus( - (req) => { - if (req.offset === 0) { - return { - response: { code: EnumStatusCode.OK }, - proposals: [{ name: 'another-proposal', state: 'DRAFT' }], - totalCount: 2, - }; - } - - return { - response: { code: EnumStatusCode.OK }, - proposals: [{ name: 'my-proposal', state: 'CLOSED' }], - totalCount: 2, - }; - }, - ['--check-all-proposals', '--json'], - (req) => { - requestedOffsets.push(req.offset); - }, - ); - - expect(requestedOffsets).toEqual([0, 1]); - expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ status: 'CLOSED' })); - expect(errorSpy).not.toHaveBeenCalled(); - expect(process.exitCode).toBeUndefined(); - }); - test('prints a json error and sets a non-zero exit code when the proposal is not found', async () => { await runStatus( { diff --git a/connect-go/gen/proto/wg/cosmo/platform/v1/platform.pb.go b/connect-go/gen/proto/wg/cosmo/platform/v1/platform.pb.go index 8fdd1783b7..d8df13eb0d 100644 --- a/connect-go/gen/proto/wg/cosmo/platform/v1/platform.pb.go +++ b/connect-go/gen/proto/wg/cosmo/platform/v1/platform.pb.go @@ -28323,6 +28323,7 @@ type GetProposalsByFederatedGraphRequest struct { EndDate string `protobuf:"bytes,4,opt,name=endDate,proto3" json:"endDate,omitempty"` Limit int32 `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"` Offset int32 `protobuf:"varint,6,opt,name=offset,proto3" json:"offset,omitempty"` + ProposalName *string `protobuf:"bytes,7,opt,name=proposalName,proto3,oneof" json:"proposalName,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -28399,6 +28400,13 @@ func (x *GetProposalsByFederatedGraphRequest) GetOffset() int32 { return 0 } +func (x *GetProposalsByFederatedGraphRequest) GetProposalName() string { + if x != nil && x.ProposalName != nil { + return *x.ProposalName + } + return "" +} + type GetProposalsByFederatedGraphResponse struct { state protoimpl.MessageState `protogen:"open.v1"` Response *Response `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"` @@ -36319,14 +36327,16 @@ const file_wg_cosmo_platform_v1_platform_proto_rawDesc = "" + "\x10currentSubgraphs\x18\x03 \x03(\v29.wg.cosmo.platform.v1.GetProposalResponse.CurrentSubgraphR\x10currentSubgraphs\x1aC\n" + "\x0fCurrentSubgraph\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12\x1c\n" + - "\tschemaSDL\x18\x02 \x01(\tR\tschemaSDL\"\xd9\x01\n" + + "\tschemaSDL\x18\x02 \x01(\tR\tschemaSDL\"\x93\x02\n" + "#GetProposalsByFederatedGraphRequest\x12.\n" + "\x12federatedGraphName\x18\x01 \x01(\tR\x12federatedGraphName\x12\x1c\n" + "\tnamespace\x18\x02 \x01(\tR\tnamespace\x12\x1c\n" + "\tstartDate\x18\x03 \x01(\tR\tstartDate\x12\x18\n" + "\aendDate\x18\x04 \x01(\tR\aendDate\x12\x14\n" + "\x05limit\x18\x05 \x01(\x05R\x05limit\x12\x16\n" + - "\x06offset\x18\x06 \x01(\x05R\x06offset\"\xf0\x01\n" + + "\x06offset\x18\x06 \x01(\x05R\x06offset\x12'\n" + + "\fproposalName\x18\a \x01(\tH\x00R\fproposalName\x88\x01\x01B\x0f\n" + + "\r_proposalName\"\xf0\x01\n" + "$GetProposalsByFederatedGraphResponse\x12:\n" + "\bresponse\x18\x01 \x01(\v2\x1e.wg.cosmo.platform.v1.ResponseR\bresponse\x12<\n" + "\tproposals\x18\x02 \x03(\v2\x1e.wg.cosmo.platform.v1.ProposalR\tproposals\x12.\n" + @@ -38520,6 +38530,7 @@ func file_wg_cosmo_platform_v1_platform_proto_init() { file_wg_cosmo_platform_v1_platform_proto_msgTypes[411].OneofWrappers = []any{} file_wg_cosmo_platform_v1_platform_proto_msgTypes[417].OneofWrappers = []any{} file_wg_cosmo_platform_v1_platform_proto_msgTypes[424].OneofWrappers = []any{} + file_wg_cosmo_platform_v1_platform_proto_msgTypes[427].OneofWrappers = []any{} file_wg_cosmo_platform_v1_platform_proto_msgTypes[431].OneofWrappers = []any{ (*UpdateProposalRequest_State)(nil), (*UpdateProposalRequest_UpdatedSubgraphs)(nil), diff --git a/connect/src/wg/cosmo/platform/v1/platform_pb.ts b/connect/src/wg/cosmo/platform/v1/platform_pb.ts index 04fb455f05..f33f28d14f 100644 --- a/connect/src/wg/cosmo/platform/v1/platform_pb.ts +++ b/connect/src/wg/cosmo/platform/v1/platform_pb.ts @@ -16,7 +16,7 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file wg/cosmo/platform/v1/platform.proto. */ export const file_wg_cosmo_platform_v1_platform: GenFile = /*@__PURE__*/ - fileDesc("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", [file_wg_cosmo_common_common, file_wg_cosmo_notifications_events]); + fileDesc("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", [file_wg_cosmo_common_common, file_wg_cosmo_notifications_events]); /** * @generated from message wg.cosmo.platform.v1.Label @@ -13618,6 +13618,11 @@ export type GetProposalsByFederatedGraphRequest = Message<"wg.cosmo.platform.v1. * @generated from field: int32 offset = 6; */ offset: number; + + /** + * @generated from field: optional string proposalName = 7; + */ + proposalName?: string | undefined; }; /** diff --git a/controlplane/src/core/bufservices/proposal/getProposalsByFederatedGraph.ts b/controlplane/src/core/bufservices/proposal/getProposalsByFederatedGraph.ts index 4710018f42..9a36cfca22 100644 --- a/controlplane/src/core/bufservices/proposal/getProposalsByFederatedGraph.ts +++ b/controlplane/src/core/bufservices/proposal/getProposalsByFederatedGraph.ts @@ -106,6 +106,7 @@ export function getProposalsByFederatedGraph( const { proposals } = await proposalRepo.ByFederatedGraphId({ federatedGraphId: federatedGraph.id, + proposalName: req.proposalName, startDate: dateRange.start, endDate: dateRange.end, limit: req.limit, @@ -114,6 +115,7 @@ export function getProposalsByFederatedGraph( const totalCount = await proposalRepo.countByFederatedGraphId({ federatedGraphId: federatedGraph.id, + proposalName: req.proposalName, startDate: dateRange.start, endDate: dateRange.end, }); diff --git a/controlplane/src/core/repositories/ProposalRepository.ts b/controlplane/src/core/repositories/ProposalRepository.ts index 97b8caba9d..f50852ce93 100644 --- a/controlplane/src/core/repositories/ProposalRepository.ts +++ b/controlplane/src/core/repositories/ProposalRepository.ts @@ -217,12 +217,14 @@ export class ProposalRepository { public async ByFederatedGraphId({ federatedGraphId, + proposalName, startDate, endDate, limit, offset, }: { federatedGraphId: string; + proposalName?: string; startDate?: string; endDate?: string; limit: number; @@ -230,6 +232,10 @@ export class ProposalRepository { }): Promise<{ proposals: { proposal: ProposalDTO; proposalSubgraphs: ProposalSubgraphDTO[] }[] }> { const conditions: (SQL | undefined)[] = []; + if (proposalName) { + conditions.push(eq(schema.proposals.name, proposalName)); + } + if (startDate && endDate) { conditions.push( gt(schema.proposals.createdAt, new Date(startDate)), @@ -322,15 +328,21 @@ export class ProposalRepository { public async countByFederatedGraphId({ federatedGraphId, + proposalName, startDate, endDate, }: { federatedGraphId: string; + proposalName?: string; startDate?: string; endDate?: string; }): Promise { const conditions: (SQL | undefined)[] = []; + if (proposalName) { + conditions.push(eq(schema.proposals.name, proposalName)); + } + if (startDate && endDate) { conditions.push( gt(schema.proposals.createdAt, new Date(startDate)), diff --git a/controlplane/test/proposal/proposal-data-isolation.test.ts b/controlplane/test/proposal/proposal-data-isolation.test.ts index 4d53871dfe..ab538444f4 100644 --- a/controlplane/test/proposal/proposal-data-isolation.test.ts +++ b/controlplane/test/proposal/proposal-data-isolation.test.ts @@ -692,6 +692,30 @@ describe('Proposal Data Isolation Tests', () => { expect(proposalNames2).toContain(proposalName2b); expect(proposalNames2).not.toContain(proposalName1); + // Filter proposals for the second federated graph by exact proposal name + const filteredProposals = await client.getProposalsByFederatedGraph({ + federatedGraphName: fedGraphName2, + namespace: DEFAULT_NAMESPACE, + proposalName: proposalName2b, + limit: 10, + offset: 0, + }); + expect(filteredProposals.response?.code).toBe(EnumStatusCode.OK); + expect(filteredProposals.proposals).toHaveLength(1); + expect(filteredProposals.proposals[0].name).toBe(proposalName2b); + expect(filteredProposals.totalCount).toBe(1); + + const missingProposal = await client.getProposalsByFederatedGraph({ + federatedGraphName: fedGraphName2, + namespace: DEFAULT_NAMESPACE, + proposalName: 'missing-proposal', + limit: 10, + offset: 0, + }); + expect(missingProposal.response?.code).toBe(EnumStatusCode.OK); + expect(missingProposal.proposals).toHaveLength(0); + expect(missingProposal.totalCount).toBe(0); + // Test getProposal - should only return proposal from the correct federated graph const proposalId1 = createProposalResponse1.proposalId; const getProposal1 = await client.getProposal({ diff --git a/docs-website/cli/proposal/status.mdx b/docs-website/cli/proposal/status.mdx index 1fca55f497..87b1f6a7fd 100644 --- a/docs-website/cli/proposal/status.mdx +++ b/docs-website/cli/proposal/status.mdx @@ -12,9 +12,7 @@ npx wgc proposal status --federation-graph [option ## Description -The `npx wgc proposal status` command checks the current status of a proposal. By default, the command searches only the 50 most recent proposals for the federated graph. - -Use `--check-all-proposals` to continue searching through all available proposal pages. Checking all proposals can be slow when the federated graph has many proposals. +The `npx wgc proposal status` command checks the current status of a proposal by its name. ## **Parameters** @@ -28,22 +26,14 @@ Use `--check-all-proposals` to continue searching through all available proposal - `-j, --json`: Print the result in JSON format instead of text. -- `--check-all-proposals`: Search all proposal pages instead of only the 50 most recent proposals. This can be slow. - ## **Examples** -### Check the 50 most recent proposals +### Check proposal status ```bash npx wgc proposal status product-changes --federation-graph my-graph ``` -### Check all proposals - -```bash -npx wgc proposal status product-changes --federation-graph my-graph --check-all-proposals -``` - ### Print JSON output ```bash diff --git a/proto/wg/cosmo/platform/v1/platform.proto b/proto/wg/cosmo/platform/v1/platform.proto index 2b5d89a410..7b9fb2c1af 100644 --- a/proto/wg/cosmo/platform/v1/platform.proto +++ b/proto/wg/cosmo/platform/v1/platform.proto @@ -3141,6 +3141,7 @@ message GetProposalsByFederatedGraphRequest { string endDate = 4; int32 limit = 5; int32 offset = 6; + optional string proposalName = 7; } message GetProposalsByFederatedGraphResponse {