Open History to see the last commit
1// @effect-diagnostics nodeBuiltinImport:off - realpathSync.native resolves Windows 8.3 short names, which the Effect realPath does not.
2import * as NodeFS from "node:fs";
3import * as NodeServices from "@effect/platform-node/NodeServices";
4import { expect, it } from "@effect/vitest";
5import * as Effect from "effect/Effect";
6import * as FileSystem from "effect/FileSystem";
7import * as Path from "effect/Path";
8
9import * as ProcessRunner from "../processRunner.ts";
10import * as RepositoryIdentityResolver from "./RepositoryIdentityResolver.ts";
11
12const normalizePathSeparators = (value: string) => value.replaceAll("\\", "/");
13const normalizeResolvedPath = (value: string) => normalizePathSeparators(value);
14
15const git = (cwd: string, args: ReadonlyArray<string>) =>
16 Effect.gen(function* () {
17 const processRunner = yield* ProcessRunner.ProcessRunner;
18 return yield* processRunner.run({
19 command: "git",
20 args: ["-C", cwd, ...args],
21 });
22 }).pipe(Effect.provide(ProcessRunner.layer));
23
24it.layer(NodeServices.layer)("RepositoryIdentityResolverLive", (it) => {
25 it.effect("normalizes equivalent GitHub remotes into a stable repository identity", () =>
26 Effect.gen(function* () {
27 const fileSystem = yield* FileSystem.FileSystem;
28 const path = yield* Path.Path;
29 const cwd = yield* fileSystem.makeTempDirectoryScoped({
30 prefix: "t3-repository-identity-test-",
31 });
32
33 yield* git(cwd, ["init"]);
34 yield* git(cwd, ["remote", "add", "origin", "git@github.com:T3Tools/t3code.git"]);
35
36 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
37 const identity = yield* resolver.resolve(cwd);
38 // Native realpath matches git's long paths when Windows temp dirs use 8.3 names.
39 const resolvedIdentityRoot =
40 identity?.rootPath === undefined ? "" : NodeFS.realpathSync.native(identity.rootPath);
41 const resolvedCwd = NodeFS.realpathSync.native(cwd);
42
43 expect(identity).not.toBeNull();
44 expect(identity?.canonicalKey).toBe("github.com/t3tools/t3code");
45 expect(normalizeResolvedPath(resolvedIdentityRoot)).toBe(normalizeResolvedPath(resolvedCwd));
46 expect(identity?.displayName).toBe("T3Tools/t3code");
47 expect(identity?.provider).toBe("github");
48 expect(identity?.owner).toBe("T3Tools");
49 expect(identity?.name).toBe("t3code");
50 expect(yield* resolver.resolve(path.join(cwd, ".git"))).toBeNull();
51 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
52 );
53
54 it.effect("identifies the host of an SSH remote that leaves its user to ssh config", () =>
55 Effect.gen(function* () {
56 const fileSystem = yield* FileSystem.FileSystem;
57 const cwd = yield* fileSystem.makeTempDirectoryScoped({
58 prefix: "t3-repository-identity-userless-remote-test-",
59 });
60
61 yield* git(cwd, ["init"]);
62 yield* git(cwd, ["remote", "add", "origin", "github.com:T3Tools/t3code.git"]);
63
64 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
65 const identity = yield* resolver.resolve(cwd);
66
67 expect(identity?.canonicalKey).toBe("github.com/t3tools/t3code");
68 expect(identity?.provider).toBe("github");
69 expect(identity?.displayName).toBe("T3Tools/t3code");
70 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
71 );
72
73 it.effect("resolves the fetch remote of a partial clone", () =>
74 Effect.gen(function* () {
75 const fileSystem = yield* FileSystem.FileSystem;
76 const cwd = yield* fileSystem.makeTempDirectoryScoped({
77 prefix: "t3-repository-identity-partial-clone-test-",
78 });
79
80 yield* git(cwd, ["init"]);
81 yield* git(cwd, ["remote", "add", "origin", "git@github.com:T3Tools/t3code.git"]);
82 yield* git(cwd, ["remote", "set-url", "--push", "origin", "git@github.com:T3Tools/push.git"]);
83 yield* git(cwd, ["config", "remote.origin.promisor", "true"]);
84 yield* git(cwd, ["config", "remote.origin.partialclonefilter", "blob:none"]);
85
86 const remotes = yield* git(cwd, ["remote", "-v"]);
87 expect(remotes.stdout).toContain("(fetch) [blob:none]");
88
89 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
90 const identity = yield* resolver.resolve(cwd);
91 expect(identity?.canonicalKey).toBe("github.com/t3tools/t3code");
92 expect(identity?.locator.remoteUrl).toBe("git@github.com:T3Tools/t3code.git");
93 expect(identity?.locator.remoteName).toBe("origin");
94 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
95 );
96
97 it.effect("returns the git top-level root path when resolving from a nested workspace", () =>
98 Effect.gen(function* () {
99 const fileSystem = yield* FileSystem.FileSystem;
100 const path = yield* Path.Path;
101 const repoRoot = yield* fileSystem.makeTempDirectoryScoped({
102 prefix: "t3-repository-identity-nested-root-test-",
103 });
104 const nestedWorkspace = path.join(repoRoot, "packages", "web");
105
106 yield* fileSystem.makeDirectory(nestedWorkspace, { recursive: true });
107 yield* git(repoRoot, ["init"]);
108 yield* git(repoRoot, ["remote", "add", "origin", "git@github.com:T3Tools/t3code.git"]);
109
110 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
111 const identity = yield* resolver.resolve(nestedWorkspace);
112 const resolvedIdentityRoot =
113 identity?.rootPath === undefined ? "" : NodeFS.realpathSync.native(identity.rootPath);
114 const resolvedRepoRoot = NodeFS.realpathSync.native(repoRoot);
115
116 expect(identity).not.toBeNull();
117 expect(identity?.canonicalKey).toBe("github.com/t3tools/t3code");
118 expect(normalizeResolvedPath(resolvedIdentityRoot)).toBe(
119 normalizeResolvedPath(resolvedRepoRoot),
120 );
121 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
122 );
123
124 it.effect.each(["bare clone", "dot-bare"] as const)(
125 "resolves a %s to its Git directory and the same identity as a checkout",
126 (layout) =>
127 Effect.gen(function* () {
128 const fileSystem = yield* FileSystem.FileSystem;
129 const path = yield* Path.Path;
130 const checkout = yield* fileSystem.makeTempDirectoryScoped({
131 prefix: "t3-repository-identity-checkout-",
132 });
133 const root = yield* fileSystem.makeTempDirectoryScoped({
134 prefix: "t3-repository-identity-bare-",
135 });
136 const bareGitDir = layout === "dot-bare" ? path.join(root, ".bare") : root;
137
138 yield* git(checkout, ["init"]);
139 yield* git(checkout, ["remote", "add", "origin", "git@github.com:T3Tools/t3code.git"]);
140 yield* git(root, ["init", "--bare", bareGitDir]);
141 if (layout === "dot-bare") {
142 yield* fileSystem.writeFileString(path.join(root, ".git"), "gitdir: ./.bare\n");
143 }
144 yield* git(root, [
145 "--git-dir",
146 bareGitDir,
147 "remote",
148 "add",
149 "origin",
150 "https://github.com/T3Tools/t3code.git",
151 ]);
152
153 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
154 const checkoutIdentity = yield* resolver.resolve(checkout);
155 expect(checkoutIdentity?.canonicalKey).toBe("github.com/t3tools/t3code");
156 const resolvedBareGitDir = NodeFS.realpathSync.native(bareGitDir);
157 const projectRoots = layout === "dot-bare" ? [root, bareGitDir] : [root];
158
159 for (const projectRoot of projectRoots) {
160 const identity = yield* resolver.resolve(projectRoot);
161 const resolvedIdentityRoot =
162 identity?.rootPath === undefined ? "" : NodeFS.realpathSync.native(identity.rootPath);
163
164 expect(identity).not.toBeNull();
165 expect(identity?.canonicalKey).toBe(checkoutIdentity?.canonicalKey);
166 expect(normalizeResolvedPath(resolvedIdentityRoot)).toBe(
167 normalizeResolvedPath(resolvedBareGitDir),
168 );
169 }
170
171 yield* git(root, ["--git-dir", bareGitDir, "remote", "remove", "origin"]);
172 for (const projectRoot of projectRoots) {
173 expect(yield* resolver.resolve(projectRoot, { refresh: true })).toBeNull();
174 }
175 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
176 );
177
178 it.effect(
179 "returns null for non-git, missing and no-remote folders, probing only what can exist",
180 () =>
181 Effect.gen(function* () {
182 const fileSystem = yield* FileSystem.FileSystem;
183 const path = yield* Path.Path;
184 const nonGitDir = yield* fileSystem.makeTempDirectoryScoped({
185 prefix: "t3-repository-identity-non-git-",
186 });
187 const gitDir = yield* fileSystem.makeTempDirectoryScoped({
188 prefix: "t3-repository-identity-no-remote-",
189 });
190
191 yield* git(gitDir, ["init"]);
192
193 const runner = yield* ProcessRunner.ProcessRunner;
194 const runs: Array<ReadonlyArray<string>> = [];
195 const resolver = yield* RepositoryIdentityResolver.make().pipe(
196 Effect.provideService(ProcessRunner.ProcessRunner, {
197 run: (input) =>
198 Effect.suspend(() => {
199 runs.push(input.args);
200 return runner.run(input);
201 }),
202 }),
203 );
204 const bareProbes = () =>
205 runs.filter((args) => args.some((arg) => arg.startsWith("--git-dir=")));
206
207 expect(yield* resolver.resolve(path.join(nonGitDir, "deleted"))).toBeNull();
208 expect(runs).toEqual([]);
209
210 expect(yield* resolver.resolve(nonGitDir)).toBeNull();
211 expect(bareProbes()).toEqual([]);
212
213 expect(yield* resolver.resolve(gitDir)).toBeNull();
214 }).pipe(Effect.provide(ProcessRunner.layer)),
215 );
216
217 it.effect("ignores local-path remotes such as GitButler's gb-local", () =>
218 Effect.gen(function* () {
219 const fileSystem = yield* FileSystem.FileSystem;
220 const localOnlyDir = yield* fileSystem.makeTempDirectoryScoped({
221 prefix: "t3-repository-identity-local-remote-",
222 });
223 const mixedDir = yield* fileSystem.makeTempDirectoryScoped({
224 prefix: "t3-repository-identity-mixed-remote-",
225 });
226
227 yield* git(localOnlyDir, ["init"]);
228 yield* git(localOnlyDir, ["remote", "add", "gb-local", "."]);
229 yield* git(localOnlyDir, ["remote", "add", "backup", "/srv/git/repo.git"]);
230 yield* git(localOnlyDir, ["remote", "add", "archive", "file:///srv/git/repo.git"]);
231 yield* git(mixedDir, ["init"]);
232 yield* git(mixedDir, ["remote", "add", "gb-local", "."]);
233 yield* git(mixedDir, ["remote", "add", "mirror", "git@github.com:T3Tools/t3code.git"]);
234
235 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
236 expect(yield* resolver.resolve(localOnlyDir)).toBeNull();
237
238 const mixedIdentity = yield* resolver.resolve(mixedDir);
239 expect(mixedIdentity?.locator.remoteName).toBe("mirror");
240 expect(mixedIdentity?.canonicalKey).toBe("github.com/t3tools/t3code");
241 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
242 );
243
244 it.effect.each(["add", "replace"] as const)(
245 "refreshes the primary upstream after %s before cache expiry",
246 (change) =>
247 Effect.gen(function* () {
248 const fileSystem = yield* FileSystem.FileSystem;
249 const cwd = yield* fileSystem.makeTempDirectoryScoped({
250 prefix: "t3-repository-identity-upstream-test-",
251 });
252
253 yield* git(cwd, ["init"]);
254 yield* git(cwd, ["remote", "add", "origin", "git@github.com:julius/t3code.git"]);
255 if (change === "replace") {
256 yield* git(cwd, ["remote", "add", "upstream", "git@github.com:T3Tools/previous.git"]);
257 }
258
259 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
260 const initialIdentity = yield* resolver.resolve(cwd);
261 expect(initialIdentity?.canonicalKey).toBe(
262 change === "add" ? "github.com/julius/t3code" : "github.com/t3tools/previous",
263 );
264
265 yield* git(cwd, [
266 "remote",
267 change === "add" ? "add" : "set-url",
268 "upstream",
269 "git@github.com:T3Tools/t3code.git",
270 ]);
271 expect(yield* resolver.resolve(cwd)).toEqual(initialIdentity);
272 const identity = yield* resolver.resolve(cwd, { refresh: true });
273
274 expect(identity).not.toBeNull();
275 expect(identity?.locator.remoteName).toBe("upstream");
276 expect(identity?.canonicalKey).toBe("github.com/t3tools/t3code");
277 expect(identity?.displayName).toBe("T3Tools/t3code");
278 expect(yield* resolver.resolve(cwd)).toEqual(identity);
279 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
280 );
281
282 it.effect("reports a fork's own remote as origin next to the upstream identity", () =>
283 Effect.gen(function* () {
284 const fileSystem = yield* FileSystem.FileSystem;
285 const cwd = yield* fileSystem.makeTempDirectoryScoped({
286 prefix: "t3-repository-identity-fork-test-",
287 });
288
289 yield* git(cwd, ["init"]);
290 yield* git(cwd, ["remote", "add", "origin", "git@github.com:julius/t3code-fork.git"]);
291 yield* git(cwd, ["remote", "add", "upstream", "git@github.com:T3Tools/t3code.git"]);
292
293 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
294 const identity = yield* resolver.resolve(cwd);
295
296 expect(identity?.canonicalKey).toBe("github.com/t3tools/t3code");
297 expect(identity?.displayName).toBe("T3Tools/t3code");
298 expect(identity?.origin).toEqual({
299 canonicalKey: "github.com/julius/t3code-fork",
300 remoteUrl: "git@github.com:julius/t3code-fork.git",
301 displayName: "julius/t3code-fork",
302 });
303 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
304 );
305
306 it.effect("uses the last remote path segment as the repository name for nested groups", () =>
307 Effect.gen(function* () {
308 const fileSystem = yield* FileSystem.FileSystem;
309 const cwd = yield* fileSystem.makeTempDirectoryScoped({
310 prefix: "t3-repository-identity-nested-group-test-",
311 });
312
313 yield* git(cwd, ["init"]);
314 yield* git(cwd, ["remote", "add", "origin", "git@gitlab.com:T3Tools/platform/t3code.git"]);
315
316 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
317 const identity = yield* resolver.resolve(cwd);
318
319 expect(identity).not.toBeNull();
320 expect(identity?.canonicalKey).toBe("gitlab.com/t3tools/platform/t3code");
321 expect(identity?.displayName).toBe("T3Tools/platform/t3code");
322 expect(identity?.owner).toBe("T3Tools");
323 expect(identity?.name).toBe("t3code");
324 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
325 );
326});