Open History to see the last commit
1import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
2import {
3 PULL_REQUEST_LIST_PROJECT_LIMIT,
4 type EnvironmentId,
5 type EnvironmentMachineKind,
6 type ProjectId,
7 type PullRequestProviderSummary,
8 type RepositoryIdentity,
9 type SourceControlProviderKind,
10} from "@t3tools/contracts";
11
12export interface AssignableProject {
13 readonly id: ProjectId;
14 readonly environmentId: EnvironmentId;
15 readonly repositoryIdentity?:
16 | Partial<Pick<RepositoryIdentity, "canonicalKey" | "provider" | "locator">>
17 | null
18 | undefined;
19}
20
21export type PullRequestHostAvailability = ReadonlyMap<
22 EnvironmentId,
23 Pick<PullRequestHostRead, "hosts" | "projectHosts">
24>;
25
26export type PullRequestHostRead = {
27 readonly observedAt: number;
28 readonly resetAt?: number;
29 readonly hosts: ReadonlyMap<
30 string,
31 { readonly configured: boolean; readonly observedAt: number }
32 >;
33 readonly projectHosts: ReadonlyMap<
34 ProjectId,
35 { readonly host: string; readonly observedAt: number }
36 >;
37};
38
39export function resetPullRequestHosts(
40 previous: ReadonlyMap<EnvironmentId, PullRequestHostRead>,
41): ReadonlyMap<EnvironmentId, PullRequestHostRead> {
42 return new Map(
43 [...previous].map(([id, read]) => [
44 id,
45 { ...read, resetAt: read.observedAt, hosts: new Map(), projectHosts: new Map() },
46 ]),
47 );
48}
49
50export function rememberPullRequestHosts(
51 previous: ReadonlyMap<EnvironmentId, PullRequestHostRead>,
52 observations: ReadonlyArray<
53 readonly [
54 EnvironmentId,
55 { readonly providers: ReadonlyArray<PullRequestProviderSummary> },
56 number,
57 ]
58 >,
59): ReadonlyMap<EnvironmentId, PullRequestHostRead> {
60 const activeHosts = new Map<
61 EnvironmentId,
62 Map<string, { configured: boolean; observedAt: number }>
63 >();
64 for (const [environmentId, { providers }, observedAt] of observations) {
65 if (observedAt <= (previous.get(environmentId)?.resetAt ?? -Infinity)) continue;
66 let hosts = activeHosts.get(environmentId);
67 if (hosts === undefined) {
68 hosts = new Map();
69 activeHosts.set(environmentId, hosts);
70 }
71 for (const provider of providers) {
72 const host = provider.host.toLowerCase();
73 const held = hosts.get(host);
74 hosts.set(host, {
75 configured: provider.configured || held?.configured === true,
76 observedAt: Math.max(observedAt, held?.observedAt ?? -Infinity),
77 });
78 }
79 }
80 let next = previous;
81 for (const [environmentId, { providers }, observedAt] of observations) {
82 const before = next.get(environmentId);
83 if (observedAt <= (before?.resetAt ?? -Infinity)) continue;
84 const hosts = new Map(before?.hosts);
85 const projectHosts = new Map(before?.projectHosts);
86 let changed = false;
87 let latestObservedAt = observedAt;
88 for (const provider of providers) {
89 const host = provider.host.toLowerCase();
90 const active = activeHosts.get(environmentId)!.get(host)!;
91 const held = hosts.get(host);
92 if (
93 active.observedAt > (held?.observedAt ?? -Infinity) ||
94 (active.observedAt === held?.observedAt && active.configured && !held.configured)
95 ) {
96 hosts.set(host, active);
97 latestObservedAt = Math.max(latestObservedAt, active.observedAt);
98 changed = true;
99 }
100 for (const projectId of provider.projectIds ?? []) {
101 if (observedAt > (projectHosts.get(projectId)?.observedAt ?? -Infinity)) {
102 projectHosts.set(projectId, { host, observedAt });
103 changed = true;
104 }
105 }
106 }
107 if (!changed) continue;
108 next = new Map(next).set(environmentId, {
109 ...before,
110 observedAt: Math.max(before?.observedAt ?? -Infinity, latestObservedAt),
111 hosts,
112 projectHosts,
113 });
114 }
115 return next;
116}
117
118function repositoryKey(project: AssignableProject): string | undefined {
119 return project.repositoryIdentity?.canonicalKey?.toLowerCase();
120}
121
122export function assignProjectsToEnvironments(
123 projects: ReadonlyArray<AssignableProject>,
124 environmentIds: ReadonlyArray<EnvironmentId>,
125 preferredEnvironmentId?: EnvironmentId | null,
126 hostAvailability?: PullRequestHostAvailability,
127): Map<EnvironmentId, ProjectId[]> {
128 const rank = new Map(environmentIds.map((id, index) => [id, index] as const));
129 const owner = new Map<string, AssignableProject>();
130 const unreadable = (project: AssignableProject) => {
131 const availability = hostAvailability?.get(project.environmentId);
132 const host =
133 availability?.projectHosts.get(project.id)?.host ??
134 sourceControlClients.changeRequestHost(
135 project.repositoryIdentity,
136 (project.repositoryIdentity?.provider ?? "unknown") as SourceControlProviderKind,
137 );
138 return availability?.hosts.get(host)?.configured === false;
139 };
140 for (const project of projects) {
141 const key = repositoryKey(project);
142 if (!key) continue;
143 const environmentRank = rank.get(project.environmentId);
144 if (environmentRank === undefined) continue;
145 const current = owner.get(key);
146 if (current === undefined) {
147 owner.set(key, project);
148 continue;
149 }
150 const currentUnreadable = unreadable(current);
151 const candidateUnreadable = unreadable(project);
152 if (currentUnreadable !== candidateUnreadable) {
153 if (currentUnreadable) owner.set(key, project);
154 continue;
155 }
156 if (current.environmentId === preferredEnvironmentId) continue;
157 if (
158 project.environmentId === preferredEnvironmentId ||
159 environmentRank < (rank.get(current.environmentId) ?? Number.MAX_SAFE_INTEGER)
160 ) {
161 owner.set(key, project);
162 }
163 }
164 const assignment = new Map<EnvironmentId, ProjectId[]>();
165 for (const project of projects) {
166 if (!rank.has(project.environmentId)) continue;
167 const key = repositoryKey(project);
168 if (key && owner.get(key)?.environmentId !== project.environmentId) continue;
169 const listed = assignment.get(project.environmentId);
170 if (listed === undefined) assignment.set(project.environmentId, [project.id]);
171 else listed.push(project.id);
172 }
173 return assignment;
174}
175
176export function pullRequestProjectQueries(
177 projects: ReadonlyArray<AssignableProject>,
178 environmentIds: ReadonlyArray<EnvironmentId>,
179 hostAvailability?: PullRequestHostAvailability,
180): ReadonlyArray<{
181 readonly environmentId: EnvironmentId;
182 readonly projectIds?: ReadonlyArray<ProjectId>;
183}> {
184 const assignment = assignProjectsToEnvironments(
185 projects,
186 environmentIds,
187 environmentIds[0],
188 hostAvailability,
189 );
190 const totals = new Map<EnvironmentId, number>();
191 for (const project of projects)
192 totals.set(project.environmentId, (totals.get(project.environmentId) ?? 0) + 1);
193 return environmentIds.flatMap((environmentId) => {
194 const projectIds = assignment.get(environmentId);
195 if (projectIds === undefined) return [];
196 if (projectIds.length === totals.get(environmentId)) return [{ environmentId }];
197 const queries: Array<{ environmentId: EnvironmentId; projectIds: ReadonlyArray<ProjectId> }> =
198 [];
199 for (let offset = 0; offset < projectIds.length; offset += PULL_REQUEST_LIST_PROJECT_LIMIT) {
200 queries.push({
201 environmentId,
202 projectIds: projectIds.slice(offset, offset + PULL_REQUEST_LIST_PROJECT_LIMIT),
203 });
204 }
205 return queries;
206 });
207}
208
209export interface PickableEnvironment {
210 readonly environmentId: EnvironmentId;
211 readonly projectId: ProjectId;
212 readonly workspaceRoot: string;
213 readonly label: string;
214 readonly machine?: EnvironmentMachineKind;
215}
216
217export function resolvePickableEnvironments(
218 current: { readonly environmentId: EnvironmentId; readonly projectId: ProjectId },
219 projects: ReadonlyArray<AssignableProject & { readonly workspaceRoot: string }>,
220 environments: ReadonlyArray<{
221 readonly environmentId: EnvironmentId;
222 readonly label: string;
223 readonly machine?: EnvironmentMachineKind;
224 }>,
225): ReadonlyArray<PickableEnvironment> {
226 const own = projects.find(
227 (project) =>
228 project.environmentId === current.environmentId && project.id === current.projectId,
229 );
230 const key = own === undefined ? undefined : repositoryKey(own);
231 const ownEnvironment = environments.find(
232 (environment) => environment.environmentId === current.environmentId,
233 );
234 if (own === undefined || !key || ownEnvironment === undefined) return [];
235 const others = environments.flatMap((environment) => {
236 if (environment.environmentId === current.environmentId) return [];
237 const copy = projects.find(
238 (project) =>
239 project.environmentId === environment.environmentId && repositoryKey(project) === key,
240 );
241 return copy === undefined
242 ? []
243 : [
244 {
245 environmentId: environment.environmentId,
246 projectId: copy.id,
247 workspaceRoot: copy.workspaceRoot,
248 label: environment.label,
249 ...(environment.machine === undefined ? {} : { machine: environment.machine }),
250 },
251 ];
252 });
253 if (others.length === 0) return [];
254 return [
255 {
256 environmentId: current.environmentId,
257 projectId: own.id,
258 workspaceRoot: own.workspaceRoot,
259 label: ownEnvironment.label,
260 ...(ownEnvironment.machine === undefined ? {} : { machine: ownEnvironment.machine }),
261 },
262 ...others,
263 ];
264}