Skip to content

Commit 67d2044

Browse files
author
Tejas Parmar
committed
fix(server): keep project-owned folders during cleanup
Consolidate the original fix and reviewed corrections into one commit. Reviewed and updated with GPT-6 in Codex.
1 parent 60b35a1 commit 67d2044

4 files changed

Lines changed: 177 additions & 43 deletions

File tree

‎apps/server/src/project/ManagedProjectFolders.test.ts‎

Lines changed: 97 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -433,38 +433,61 @@ it.effect("keeps a named project and reports why when Git cannot commit", () =>
433433
),
434434
);
435435

436-
it.effect("keeps a folder that another project owns when the create conflicts", () =>
437-
withScratch(({ baseDir }) =>
438-
withGitEnv(
439-
TEST_IDENTITY,
440-
Effect.gen(function* () {
441-
const folders = yield* ManagedProjectFolders.ManagedProjectFolders;
442-
const projects = yield* ProjectService.ProjectService;
443-
const fileSystem = yield* FileSystem.FileSystem;
444-
const path = yield* Path.Path;
445-
const taken = path.join(folders.namedProjectsRoot, "taken");
446-
yield* projects.create({
447-
commandId: CommandId.make("command:owner"),
448-
projectId: ProjectId.make("project:owner"),
449-
title: "Owner",
450-
workspaceRoot: taken,
451-
createWorkspaceRootIfMissing: true,
452-
});
453-
yield* fileSystem.remove(taken, { recursive: true });
454-
455-
const failure = yield* Effect.flip(folders.createNamedProject({ name: "Taken" }));
456-
457-
assert.equal(failure._tag, "NamedProjectCreateError");
458-
assert.equal(failure.message, "Failed to create the project.");
459-
assert.isTrue(yield* fileSystem.exists(path.join(taken, "README.md")));
460-
const owner = yield* projects.getByWorkspaceRoot(taken);
461-
assert.equal(Option.getOrThrow(owner).id, ProjectId.make("project:owner"));
462-
assert.deepEqual(yield* fileSystem.readDirectory(path.resolve(baseDir, "projects")), [
463-
"taken",
464-
]);
465-
}),
436+
it.effect.each([false, true])(
437+
"keeps a conflicted folder even if its owner was deleted: %s",
438+
(deleted) =>
439+
withScratch(
440+
({ baseDir }) =>
441+
withGitEnv(
442+
TEST_IDENTITY,
443+
Effect.gen(function* () {
444+
const folders = yield* ManagedProjectFolders.ManagedProjectFolders;
445+
const projects = yield* ProjectService.ProjectService;
446+
const fileSystem = yield* FileSystem.FileSystem;
447+
const path = yield* Path.Path;
448+
const taken = path.join(folders.namedProjectsRoot, "taken");
449+
yield* projects.create({
450+
commandId: CommandId.make("command:owner"),
451+
projectId: ProjectId.make("project:owner"),
452+
title: "Owner",
453+
workspaceRoot: taken,
454+
createWorkspaceRootIfMissing: true,
455+
});
456+
yield* fileSystem.remove(taken, { recursive: true });
457+
458+
const failure = yield* Effect.flip(folders.createNamedProject({ name: "Taken" }));
459+
460+
assert.equal(failure._tag, "NamedProjectCreateError");
461+
assert.equal(failure.message, "Failed to create the project.");
462+
assert.isTrue(yield* fileSystem.exists(path.join(taken, "README.md")));
463+
const owner = yield* projects.getByWorkspaceRoot(taken);
464+
if (deleted) assert.isTrue(Option.isNone(owner));
465+
else assert.equal(Option.getOrThrow(owner).id, ProjectId.make("project:owner"));
466+
assert.deepEqual(yield* fileSystem.readDirectory(path.resolve(baseDir, "projects")), [
467+
"taken",
468+
]);
469+
}),
470+
),
471+
{
472+
projects: (real) =>
473+
ProjectService.ProjectService.of({
474+
...real,
475+
create: (input) =>
476+
real.create(input).pipe(
477+
Effect.tapError((error) =>
478+
deleted && error._tag === "ProjectConflictError"
479+
? real
480+
.delete({
481+
commandId: CommandId.make("delete-conflicting-owner"),
482+
projectId: error.conflictingProjectId,
483+
})
484+
.pipe(Effect.asVoid)
485+
: Effect.void,
486+
),
487+
),
488+
}),
489+
},
466490
),
467-
),
468491
);
469492

470493
it.effect("removes the folder when the project create is rejected for another reason", () =>
@@ -533,3 +556,46 @@ it.effect("removes the folder when the create is cancelled before the project ex
533556
);
534557
}),
535558
);
559+
560+
it.effect("keeps a folder another project claims while scaffolding is cancelled", () =>
561+
Effect.gen(function* () {
562+
const scaffolding = yield* Deferred.make<void>();
563+
yield* withScratch(
564+
() =>
565+
Effect.gen(function* () {
566+
const folders = yield* ManagedProjectFolders.ManagedProjectFolders;
567+
const projects = yield* ProjectService.ProjectService;
568+
const fileSystem = yield* FileSystem.FileSystem;
569+
const path = yield* Path.Path;
570+
const workspaceRoot = path.join(folders.namedProjectsRoot, "claimed");
571+
const fiber = yield* folders
572+
.createNamedProject({ name: "Claimed" })
573+
.pipe(Effect.forkChild);
574+
yield* Deferred.await(scaffolding);
575+
const owner = yield* projects.create({
576+
commandId: CommandId.make("command:claimed-owner"),
577+
projectId: ProjectId.make("project:claimed-owner"),
578+
title: "Claimed owner",
579+
workspaceRoot,
580+
});
581+
const ownerFile = path.join(workspaceRoot, "owner.txt");
582+
yield* fileSystem.writeFileString(ownerFile, "keep\n");
583+
584+
yield* Fiber.interrupt(fiber);
585+
586+
assert.isTrue(yield* fileSystem.exists(ownerFile));
587+
assert.equal(
588+
Option.getOrThrow(yield* projects.getByWorkspaceRoot(workspaceRoot)).id,
589+
owner.id,
590+
);
591+
}),
592+
{
593+
git: Layer.mock(GitVcsDriver.GitVcsDriver)({
594+
readConfigValue: () => Effect.succeed(null),
595+
execute: () =>
596+
Deferred.succeed(scaffolding, undefined).pipe(Effect.andThen(Effect.never)),
597+
}),
598+
},
599+
);
600+
}),
601+
);

‎apps/server/src/project/ManagedProjectFolders.ts‎

Lines changed: 7 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -436,14 +436,19 @@ const make = Effect.gen(function* () {
436436
)(function* (input) {
437437
const workspaceRoot = yield* claimNamedFolder(input.name);
438438
const removeFolder = fileSystem.remove(workspaceRoot, { recursive: true }).pipe(Effect.ignore);
439+
// Another create can register the claimed path while scaffolding runs.
440+
// A failed ownership lookup keeps data rather than risking its deletion.
441+
const removeFolderIfUnowned = projects
442+
.whileWorkspaceUnowned(workspaceRoot, removeFolder)
443+
.pipe(Effect.ignore);
439444
const prepared = yield* Effect.all([
440445
scaffoldRepository(workspaceRoot, input.name).pipe(
441446
Effect.mapError((cause) => new NamedProjectFolderError({ folder: workspaceRoot, cause })),
442447
),
443448
crypto
444449
.randomUUIDv4()
445450
.pipe(Effect.mapError((cause) => new NamedProjectCreateError({ workspaceRoot, cause }))),
446-
]).pipe(Effect.onExit((exit) => (Exit.isSuccess(exit) ? Effect.void : removeFolder)));
451+
]).pipe(Effect.onExit((exit) => (Exit.isSuccess(exit) ? Effect.void : removeFolderIfUnowned)));
447452
const [commitError, id] = prepared;
448453
const project = yield* projects
449454
.create({
@@ -453,18 +458,8 @@ const make = Effect.gen(function* () {
453458
workspaceRoot,
454459
})
455460
.pipe(
456-
// A rejected create leaves the folder unused, so remove it. An
457-
// interrupt can land after the create is committed, and a conflict
458-
// means another project owns the folder, so it stays then; the owner
459-
// is checked again first, since deleting another project's files is
460-
// never acceptable.
461461
Effect.tapError((error) =>
462-
error._tag === "ProjectConflictError"
463-
? Effect.void
464-
: projects.getByWorkspaceRoot(workspaceRoot).pipe(
465-
Effect.flatMap((owner) => (Option.isNone(owner) ? removeFolder : Effect.void)),
466-
Effect.ignore,
467-
),
462+
error._tag === "ProjectConflictError" ? Effect.void : removeFolderIfUnowned,
468463
),
469464
Effect.mapError((cause) => new NamedProjectCreateError({ workspaceRoot, cause })),
470465
);

‎apps/server/src/project/ProjectService.test.ts‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -669,3 +669,47 @@ it.effect("rejects an update that waited on the lock while its project was delet
669669
);
670670
}).pipe(Effect.provide(layerProjectServiceDependencies)),
671671
);
672+
673+
it.effect("serializes unowned-folder cleanup with a project registration already committing", () =>
674+
Effect.gen(function* () {
675+
const eventSink = yield* EventSink.EventSinkV2;
676+
const firstReachedCommit = yield* Deferred.make<void>();
677+
const releaseFirst = yield* Deferred.make<void>();
678+
const gatedSink = EventSink.EventSinkV2.of({
679+
...eventSink,
680+
commitProjectCommand: (input) =>
681+
input.projectId === "project:race:first"
682+
? Deferred.succeed(firstReachedCommit, undefined).pipe(
683+
Effect.andThen(Deferred.await(releaseFirst)),
684+
Effect.andThen(eventSink.commitProjectCommand(input)),
685+
)
686+
: eventSink.commitProjectCommand(input),
687+
});
688+
const service = yield* ProjectService.make.pipe(
689+
Effect.provideService(EventSink.EventSinkV2, gatedSink),
690+
);
691+
const claim = (name: string) =>
692+
service.create({
693+
commandId: CommandId.make(`command:race:${name}`),
694+
projectId: ProjectId.make(`project:race:${name}`),
695+
title: name,
696+
workspaceRoot: "/work/race",
697+
});
698+
const first = yield* claim("first").pipe(Effect.forkChild({ startImmediately: true }));
699+
yield* Deferred.await(firstReachedCommit);
700+
let removed = false;
701+
const second = yield* service
702+
.whileWorkspaceUnowned(
703+
"/work/race/",
704+
Effect.sync(() => {
705+
removed = true;
706+
}),
707+
)
708+
.pipe(Effect.forkChild({ startImmediately: true }));
709+
assert.isUndefined(second.pollUnsafe());
710+
yield* Deferred.succeed(releaseFirst, undefined);
711+
assert.equal((yield* Fiber.join(first)).id, "project:race:first");
712+
yield* Fiber.join(second);
713+
assert.isFalse(removed);
714+
}).pipe(Effect.provide(layerProjectServiceDependencies)),
715+
);

‎apps/server/src/project/ProjectService.ts‎

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -130,6 +130,10 @@ export class ProjectService extends Context.Service<
130130
workspaceRoot: string,
131131
options?: { readonly includeDeleted?: boolean },
132132
) => Effect.Effect<Option.Option<Project>, ProjectOperationError>;
133+
readonly whileWorkspaceUnowned: <E, R>(
134+
workspaceRoot: string,
135+
effect: Effect.Effect<void, E, R>,
136+
) => Effect.Effect<void, E | ProjectOperationError, R>;
133137
readonly snapshot: Effect.Effect<ProjectSnapshot, ProjectOperationError>;
134138
readonly getShell: (
135139
projectId: ProjectId,
@@ -216,6 +220,8 @@ export const make = Effect.gen(function* () {
216220
new ProjectOperationError({ operation: "dispatch-project-command", projectId, cause });
217221
const workspaceRoot = command.type === "project.delete" ? undefined : command.workspaceRoot;
218222
const planAndCommit = Effect.gen(function* () {
223+
// Cleanup can remove an unowned folder while registration waits for the workspace lock.
224+
if (workspaceRoot !== undefined) yield* normalizeWorkspaceRoot({ workspaceRoot });
219225
const project = Option.getOrUndefined(yield* readRow(projectId, { includeDeleted: true }));
220226
const workspaceOwner =
221227
workspaceRoot === undefined
@@ -325,6 +331,28 @@ export const make = Effect.gen(function* () {
325331
return Option.isNone(row) ? Option.none() : Option.some(yield* hydrate(row.value));
326332
});
327333

334+
const whileWorkspaceUnowned: ProjectService["Service"]["whileWorkspaceUnowned"] = Effect.fn(
335+
"ProjectService.whileWorkspaceUnowned",
336+
)(function* <E, R>(workspaceRoot: string, effect: Effect.Effect<void, E, R>) {
337+
const normalized = yield* normalizeWorkspaceRoot({ workspaceRoot });
338+
yield* workspaceLocks.withLock(
339+
normalized,
340+
Effect.gen(function* () {
341+
const owner = yield* projects.findActiveByWorkspaceRoot(normalized).pipe(
342+
Effect.mapError(
343+
(cause) =>
344+
new ProjectOperationError({
345+
operation: "read-project",
346+
workspaceRoot: normalized,
347+
cause,
348+
}),
349+
),
350+
);
351+
if (Option.isNone(owner)) yield* effect;
352+
}),
353+
);
354+
});
355+
328356
const create: ProjectService["Service"]["create"] = Effect.fn("ProjectService.create")(
329357
function* (input) {
330358
const workspaceRoot = yield* normalizeWorkspaceRoot({
@@ -569,6 +597,7 @@ export const make = Effect.gen(function* () {
569597
delete: deleteProject,
570598
getById,
571599
getByWorkspaceRoot,
600+
whileWorkspaceUnowned,
572601
snapshot,
573602
getShell,
574603
listShells,

0 commit comments

Comments
 (0)