pigui/task-stream
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: move unfinished tickets between releases

Browse Source 
- Bulk editing gets «Release…» (open releases or none), and the list
  view a release filter, also reachable from each release («Ver en la
  lista», ?release=).
- Archiving a release asks where its unfinished tickets go, as closing
  a sprint does: ReleaseArchivedEvent carries `moveTo` (an open release
  of the same project, or none) and the saga moves them there; finished
  ones stay. In GraphQL, REST and the MCP's archive_release.
- Chapter 10 lists the next features and the ideas to weigh.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Josep Piguillem
2026-10-14 21:55:45 +02:00
parent 0a73eda9b2
commit 993f80b4b9
34 changed files with 408 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
libs/api/tracker/application/src/lib/commands/archive-release.command-handler.ts
View File

@@ -11,10 +11,12 @@ export class ArchiveReleaseCommandHandler
async execute(command: ArchiveReleaseCommand): Promise<CommandResult> {
const release = await this.access.release(command.releaseId);
(await this.access.project(release.projectId)).assertCanManage(
command.actorId,
);
release.archive(command.actorId);
const project = await this.access.project(release.projectId);
project.assertCanManage(command.actorId);
// The tickets can only go to an open release of the same project.
if (command.moveTo && command.moveTo !== release.id)
await this.access.openReleaseOf(project, command.moveTo);
release.archive(command.actorId, command.moveTo);
await release.commitAndWait();
return ack(release);
}

2
libs/api/tracker/application/src/lib/commands/archive-release.command.ts
View File

@@ -5,6 +5,8 @@ export class ArchiveReleaseCommand extends Command<CommandResult> {
constructor(
public readonly actorId: string,
public readonly releaseId: string,
/** Open release of the same project for its unfinished tickets. */
public readonly moveTo: string | null = null,
) {
super();
}

16
libs/api/tracker/application/src/lib/commands/detach-issue-from-release.command-handler.ts
View File

@@ -15,7 +15,21 @@ export class DetachIssueFromReleaseCommandHandler
const project = await this.access.live(issue.projectId, Project);
// Finished tickets stay: they are what the release shipped.
if (!project || project.workflow.isFinished(issue.status)) return;
issue.setRelease(command.actorId, null);
issue.setRelease(command.actorId, await this.target(project, command));
await issue.commitAndWait();
}
/** The release chosen when archiving, if it still takes tickets. */
private async target(
project: Project,
command: DetachIssueFromReleaseCommand,
): Promise<string | null> {
if (!command.toReleaseId) return null;
try {
await this.access.openReleaseOf(project, command.toReleaseId);
return command.toReleaseId;
} catch {
return null;
}
}
}

6
libs/api/tracker/application/src/lib/commands/detach-issue-from-release.command.ts
View File

@@ -1,11 +1,15 @@
import { Command } from '@nestjs/cqrs';
/** Saga only: takes an unfinished ticket out of an archived release. */
/**
* Saga only: takes an unfinished ticket out of an archived release, to
* `toReleaseId` or to none.
*/
export class DetachIssueFromReleaseCommand extends Command<void> {
constructor(
public readonly actorId: string,
public readonly issueId: string,
public readonly releaseId: string,
public readonly toReleaseId: string | null = null,
) {
super();
}

9
libs/api/tracker/application/src/lib/releases.service.ts
View File

@@ -66,9 +66,14 @@ export class ReleasesService {
);
}
archive(actorId: string, releaseId: string): Promise<CommandResult> {
/** @param moveTo open release for its unfinished tickets (none: they leave it) */
archive(
actorId: string,
releaseId: string,
moveTo: string | null = null,
): Promise<CommandResult> {
return this.commandBus.execute(
new ArchiveReleaseCommand(actorId, releaseId),
new ArchiveReleaseCommand(actorId, releaseId, moveTo),
);
}

6
libs/api/tracker/application/src/lib/sagas/release-archived.saga.ts
View File

@@ -7,8 +7,9 @@ import { ReleaseIssuesRepository } from '../ports/release-issues.repository';
/**
* An archived release no longer accepts changes, so its unfinished tickets
* would be stuck in it: they leave it (back to "no release"), attributed to
* whoever archived it. Finished tickets stay, as the record of what shipped.
* would be stuck in it: they move to the release chosen when archiving it,
* or back to "no release", attributed to whoever archived it. Finished
* tickets stay, as the record of what shipped.
*/
@Injectable()
export class ReleaseArchivedSaga {
@@ -27,6 +28,7 @@ export class ReleaseArchivedSaga {
event.actorId,
issueId,
event.aggregateId,
event.moveTo ?? null,
),
),
),

39
libs/api/tracker/application/src/lib/sagas/sagas.spec.ts
View File

@@ -306,6 +306,45 @@ describe('sagas', () => {
expect((await rehydrator.rehydrate(done, Issue)).releaseId).toBe(release);
});
it('archiving a release can hand its unfinished tickets to another', async () => {
const { run, drain, rehydrator } = await setup();
const web = (await run(new CreateProjectCommand('owner', 'WEB', 'Web'))).id;
const old = (
await run(new CreateReleaseCommand('owner', web, 'v1', null, null))
).id;
const next = (
await run(new CreateReleaseCommand('owner', web, 'v2', null, null))
).id;
const open = (
await run(
new CreateIssueCommand('owner', web, 'TASK', 'open', {}, null, old),
)
).id;
const done = (
await run(
new CreateIssueCommand('owner', web, 'TASK', 'done', {}, null, old),
)
).id;
for (const status of ['TODO', 'IN_PROGRESS', 'IN_REVIEW', 'DONE'])
await run(new ChangeIssueStatusCommand('owner', done, status));
// Only an open release of the same project takes them.
const other = (await run(new CreateProjectCommand('owner', 'API', 'Api')))
.id;
const elsewhere = (
await run(new CreateReleaseCommand('owner', other, 'v9', null, null))
).id;
await expect(
run(new ArchiveReleaseCommand('owner', old, elsewhere)),
).rejects.toThrow(/another project/);
await run(new ArchiveReleaseCommand('owner', old, next));
await drain();
expect((await rehydrator.rehydrate(open, Issue)).releaseId).toBe(next);
expect((await rehydrator.rehydrate(done, Issue)).releaseId).toBe(old);
});
it('a user deactivated in Pireon leaves their open tickets unassigned', async () => {
const { run, react, rehydrator, openAssigned } = await setup();
const web = (await run(new CreateProjectCommand('owner', 'WEB', 'Web'))).id;

13
libs/api/tracker/domain/src/lib/events/release-archived.event.ts
View File

@@ -1,10 +1,19 @@
import { AutowiredEvent } from '@task-stream/api/shared/domain';
import { TrackerEvent } from './tracker.event';
/** The release was archived. */
/**
* The release was archived. Its unfinished tickets move to `moveTo` (an
* open release of the same project) or, when null, leave it. Events stored
* before `moveTo` existed read as null.
*/
@AutowiredEvent
export class ReleaseArchivedEvent extends TrackerEvent {
constructor(actorId: string, releaseId: string, projectId: string) {
constructor(
actorId: string,
releaseId: string,
projectId: string,
readonly moveTo: string | null = null,
) {
super(actorId, releaseId, projectId);
}
}

8
libs/api/tracker/domain/src/lib/release/release.ts
View File

@@ -132,9 +132,13 @@ export class Release extends VersionedAggregateRoot implements ReleaseProps {
);
}
archive(actorId: string): void {
/** @param moveTo where its unfinished tickets go (null: no release) */
archive(actorId: string, moveTo: string | null = null): void {
if (this.status === ReleaseStatus.ARCHIVED) return;
this.apply(new ReleaseArchivedEvent(actorId, this.id, this.projectId));
assertThat(moveTo !== this.id, 'A release cannot take its own tickets');
this.apply(
new ReleaseArchivedEvent(actorId, this.id, this.projectId, moveTo),
);
}
/** Deletes the release (its project was deleted). Idempotent. */

9
libs/api/tracker/presenters/src/lib/graphql/release.resolver.ts
View File

@@ -146,7 +146,14 @@ export class ReleaseResolver {
archiveRelease(
@CurrentUser() me: User,
@Args('releaseId', { type: () => ID }) releaseId: string,
@Args('moveTo', {
type: () => ID,
nullable: true,
description:
'Open release of the same project that takes its unfinished tickets; none: they leave it',
})
moveTo?: string | null,
) {
return this.releases.archive(me.id, releaseId);
return this.releases.archive(me.id, releaseId, moveTo ?? null);
}
}

13
libs/api/tracker/presenters/src/lib/http/dto/requests.dto.ts
View File

@@ -1148,6 +1148,19 @@ export class SetIssueSprintDto {
sprintId!: string | null;
}
export class ArchiveReleaseDto {
@ApiPropertyOptional({
type: String,
nullable: true,
format: 'uuid',
description:
'Open release of the same project that takes its unfinished tickets; null or absent: they leave it',
})
@IsOptional()
@IsUUID()
moveTo?: string | null;
}
export class PublishReleaseDto {
@ApiPropertyOptional({
type: Boolean,

15
libs/api/tracker/presenters/src/lib/http/releases.controller.ts
View File

@@ -34,6 +34,7 @@ import {
import {
CreateReleaseDto,
PageQueryDto,
ArchiveReleaseDto,
PublishReleaseDto,
ReleaseNotesDto,
UpcomingReleasesQueryDto,
@@ -234,10 +235,18 @@ export class ReleasesController {
@Post('releases/:releaseId/archive')
@HttpCode(200)
@ApiOperation({ summary: 'Archive a planned release (its tickets leave it)' })
@ApiOperation({
summary: 'Archive a planned release',
description:
'Its unfinished tickets move to `moveTo` (an open release of the same project) or leave it.',
})
@ApiOkResponse({ type: CommandResultDto })
@ApiCommandErrors()
archive(@CurrentUser() me: User, @Param('releaseId') releaseId: string) {
return this.releases.archive(me.id, releaseId);
archive(
@CurrentUser() me: User,
@Param('releaseId') releaseId: string,
@Body() body: ArchiveReleaseDto,
) {
return this.releases.archive(me.id, releaseId, body?.moveTo ?? null);
}
}