Open History to see the last commit
1import * as Arr from "effect/Array";
2import * as Context from "effect/Context";
3import * as Queue from "effect/Queue";
4import * as Tracer from "effect/Tracer";
5import { assert, it } from "@effect/vitest";
6import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
7import * as NodeServices from "@effect/platform-node/NodeServices";
8import { CommandId, type Project, ProjectId, ProviderInstanceId } from "@t3tools/contracts";
9import * as Deferred from "effect/Deferred";
10import * as Effect from "effect/Effect";
11import * as Fiber from "effect/Fiber";
12import * as Layer from "effect/Layer";
13import * as Metric from "effect/Metric";
14import * as Option from "effect/Option";
15import * as PubSub from "effect/PubSub";
16import * as Ref from "effect/Ref";
17import { TestClock } from "effect/testing";
18import * as SqlClient from "effect/sql/SqlClient";
19
20import * as ServerConfig from "../config.ts";
21import {
22 orchestrationCommandDuration,
23 orchestrationCommandsTotal,
24} from "../observability/Metrics.ts";
25import * as EventSink from "../orchestration-v2/EventSink.ts";
26import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
27import * as LegacyV1ThreadImporter from "../orchestration-v2/legacy/LegacyV1ThreadImporter.ts";
28import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
29import * as ProjectStore from "../orchestration-v2/ProjectStore.ts";
30import * as RuntimeLayer from "../orchestration-v2/runtimeLayer.ts";
31import * as ThreadCommandExecutor from "../orchestration-v2/ThreadCommandExecutor.ts";
32import * as SqlitePersistence from "../persistence/Sqlite.ts";
33import * as ServerSettings from "../serverSettings.ts";
34import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
35import * as ProjectEnrichmentService from "./ProjectEnrichmentService.ts";
36import * as ProjectFaviconResolver from "./ProjectFaviconResolver.ts";
37import * as ProjectService from "./ProjectService.ts";
38import * as RepositoryIdentityResolver from "./RepositoryIdentityResolver.ts";
39
40const layerWorkspacePaths = Layer.succeed(WorkspacePaths.WorkspacePaths, {
41 normalizeWorkspaceRoot: (workspaceRoot) => Effect.succeed(workspaceRoot.replace(/\/$/, "")),
42 resolveRelativePathWithinRoot: ({ workspaceRoot, relativePath }) =>
43 Effect.succeed({ absolutePath: `${workspaceRoot}/${relativePath}`, relativePath }),
44});
45
46const layerMetadata = Layer.merge(
47 Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
48 resolve: (workspaceRoot) =>
49 Effect.succeed({
50 canonicalKey: `github.com/t3tools/${workspaceRoot.split("/").at(-1)}`,
51 locator: {
52 source: "git-remote" as const,
53 remoteName: "origin",
54 remoteUrl: `git@github.com:t3tools/${workspaceRoot.split("/").at(-1)}.git`,
55 },
56 rootPath: workspaceRoot,
57 }),
58 }),
59 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
60 invalidate: () => Effect.void,
61 resolvePath: (workspaceRoot) => Effect.succeed(`${workspaceRoot}/favicon.svg`),
62 }),
63);
64
65class EnrichmentCompletions extends Context.Service<EnrichmentCompletions, Queue.Queue<void>>()(
66 "t3/project/ProjectService.test/EnrichmentCompletions",
67) {}
68
69const layerEnrichmentCompletions = Layer.effectContext(
70 Effect.gen(function* () {
71 const completions = yield* Queue.unbounded<void>();
72 const tracer = Tracer.make({
73 span: (options) => {
74 const span = new Tracer.NativeSpan(options);
75 const end = span.end.bind(span);
76 span.end = (...args) => {
77 end(...args);
78 if (
79 span.name === "ProjectEnrichmentService.resolveRepositoryIdentity" ||
80 span.name === "ProjectEnrichmentService.resolveFavicon"
81 ) {
82 Queue.offerUnsafe(completions, undefined);
83 }
84 };
85 return span;
86 },
87 });
88 return Context.make(EnrichmentCompletions, completions).pipe(
89 Context.add(Tracer.Tracer, tracer),
90 );
91 }),
92);
93
94const layerTestFor = (
95 projectMetadataLayer: Layer.Layer<
96 | ProjectFaviconResolver.ProjectFaviconResolver
97 | RepositoryIdentityResolver.RepositoryIdentityResolver
98 >,
99) =>
100 RuntimeLayer.layerProjectService.pipe(
101 Layer.provideMerge(ProjectEnrichmentService.layer),
102 Layer.provideMerge(layerWorkspacePaths),
103 Layer.provideMerge(projectMetadataLayer),
104 Layer.provideMerge(SqlitePersistence.layerMemory),
105 Layer.provideMerge(ServerSettings.layerTest()),
106 Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "project-service-test-" })),
107 Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
108 Layer.provideMerge(layerEnrichmentCompletions),
109 );
110
111const layerTest = layerTestFor(layerMetadata);
112
113it.effect("resolves only the requested active project page in creation order", () =>
114 Effect.gen(function* () {
115 const inspected = yield* Ref.make<ReadonlySet<string>>(new Set());
116 const note = (workspaceRoot: string) =>
117 Ref.update(inspected, (roots) => new Set([...roots, workspaceRoot]));
118 const metadata = Layer.merge(
119 Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
120 resolve: (workspaceRoot) =>
121 note(workspaceRoot).pipe(
122 Effect.as({
123 canonicalKey: `example.test${workspaceRoot}`,
124 locator: {
125 source: "git-remote" as const,
126 remoteName: "origin",
127 remoteUrl: `https://example.test${workspaceRoot}.git`,
128 },
129 rootPath: workspaceRoot,
130 }),
131 ),
132 }),
133 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
134 invalidate: () => Effect.void,
135 resolvePath: (workspaceRoot) => note(workspaceRoot).pipe(Effect.as(null)),
136 }),
137 );
138 yield* Effect.gen(function* () {
139 const sql = yield* SqlClient.SqlClient;
140 const service = yield* ProjectService.ProjectService;
141 const enrichment = yield* ProjectEnrichmentService.ProjectEnrichmentService;
142 const changes = yield* enrichment.subscribeChanges;
143 const rows = Arr.makeBy(6, (index) => ({
144 project_id: `page:${index}`,
145 title: `Project ${index}`,
146 workspace_root: `/work/page-${index}`,
147 scripts_json: "[]",
148 created_at: "2026-10-01T00:00:00.000Z",
149 updated_at: "2026-10-01T00:00:00.000Z",
150 deleted_at: index === 1 ? "2026-10-02T00:00:00.000Z" : null,
151 auto_pull: 0,
152 }));
153 yield* sql`INSERT INTO projection_projects ${sql.insert(rows)}`;
154 const first = yield* service.listPage({ cursor: 0, limit: 2 });
155 assert.deepEqual(
156 first.projects.map((project) => project.id),
157 ["page:0", "page:2"],
158 );
159 assert.equal(first.nextCursor, 2);
160 assert.deepEqual(
161 first.projects.map((project) => project.repositoryIdentity?.canonicalKey),
162 ["example.test/work/page-0", "example.test/work/page-2"],
163 );
164 // A sentinel queued after the page lets the enrichment workers finish
165 // earlier requests before checking which workspaces were inspected.
166 yield* enrichment.request("/work/page-sentinel");
167 for (;;) {
168 if ((yield* PubSub.take(changes)).workspaceRoot === "/work/page-sentinel") break;
169 }
170 assert.deepEqual(
171 new Set(yield* Ref.get(inspected)),
172 new Set(["/work/page-0", "/work/page-2", "/work/page-sentinel"]),
173 );
174 const second = yield* service.listPage({ cursor: first.nextCursor!, limit: 2 });
175 assert.deepEqual(
176 second.projects.map((project) => project.id),
177 ["page:3", "page:4"],
178 );
179 assert.equal(second.nextCursor, 4);
180 const last = yield* service.listPage({ cursor: second.nextCursor!, limit: 2 });
181 assert.deepEqual(
182 last.projects.map((project) => project.id),
183 ["page:5"],
184 );
185 assert.isNull(last.nextCursor);
186 assert.isFalse((yield* Ref.get(inspected)).has("/work/page-1"));
187 assert.deepEqual(yield* service.listPage({ cursor: 99, limit: 2 }), {
188 projects: [],
189 nextCursor: null,
190 });
191 }).pipe(Effect.scoped, Effect.provide(layerTestFor(metadata)));
192 }),
193);
194
195const layerProjectServiceDependencies = Layer.mergeAll(
196 RuntimeLayer.layerEventSink,
197 ProjectStore.layer,
198 ProjectionStore.layer,
199 IdAllocator.layer,
200 ThreadCommandExecutor.layer,
201).pipe(
202 Layer.provideMerge(LegacyV1ThreadImporter.layer.pipe(Layer.provide(RuntimeLayer.layerEventSink))),
203 Layer.provideMerge(ProjectEnrichmentService.layer),
204 Layer.provideMerge(layerWorkspacePaths),
205 Layer.provideMerge(layerMetadata),
206 Layer.provideMerge(SqlitePersistence.layerMemory),
207 Layer.provideMerge(ServerSettings.layerTest()),
208 Layer.provideMerge(ServerConfig.layerTest(process.cwd(), { prefix: "project-service-race-" })),
209 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
210);
211
212const waitForProject = Effect.fn("ProjectServiceTest.waitForProject")(function* (
213 service: ProjectService.ProjectService["Service"],
214 projectId: ProjectId,
215 predicate: (project: Project) => boolean,
216) {
217 return yield* Effect.scoped(
218 Effect.gen(function* () {
219 const completions = yield* EnrichmentCompletions;
220 for (;;) {
221 const project = Option.getOrThrow(yield* service.getById(projectId));
222 if (predicate(project)) return project;
223 yield* Queue.take(completions);
224 }
225 }),
226 );
227});
228
229it.layer(layerTest)("ProjectService", (it) => {
230 it.effect("creates, updates, resolves, snapshots, and soft-deletes projects", () =>
231 Effect.gen(function* () {
232 const service = yield* ProjectService.ProjectService;
233 const projectId = ProjectId.make("project:service-test");
234 const modelSelection = {
235 instanceId: ProviderInstanceId.make("codex_custom"),
236 model: "gpt-5.1-codex",
237 } as const;
238 yield* TestClock.setTime(Date.parse("2026-06-20T10:00:00.000Z"));
239
240 const created = yield* service.create({
241 commandId: CommandId.make("command:project:create"),
242 projectId,
243 title: "Project",
244 workspaceRoot: "/work/project/",
245 defaultModelSelection: modelSelection,
246 scripts: [
247 {
248 id: "setup",
249 name: "Setup",
250 command: "vp install",
251 icon: "configure",
252 runOnWorktreeCreate: true,
253 },
254 ],
255 });
256 assert.equal(created.workspaceRoot, "/work/project");
257 assert.isNull(created.repositoryIdentity);
258 assert.isNull(created.faviconPath);
259
260 const hydratedCreated = yield* waitForProject(
261 service,
262 projectId,
263 (project) => project.repositoryIdentity !== null && project.faviconPath !== null,
264 );
265 assert.equal(hydratedCreated?.repositoryIdentity?.canonicalKey, "github.com/t3tools/project");
266 assert.equal(hydratedCreated?.faviconPath, "/work/project/favicon.svg");
267
268 const updated = yield* service.update({
269 commandId: CommandId.make("command:project:update"),
270 projectId,
271 title: "Renamed",
272 autoPull: true,
273 projectIcon: { kind: "emoji", emoji: "🦊" },
274 faviconPath: "/work/project/custom.svg",
275 defaultThreadEnvMode: "worktree",
276 });
277 assert.equal(updated.title, "Renamed");
278 assert.equal(updated.createdAt, created.createdAt);
279 assert.isTrue(updated.autoPull);
280 assert.deepEqual(updated.projectIcon, { kind: "emoji", emoji: "🦊" });
281 assert.equal(updated.faviconPath, "/work/project/custom.svg");
282 assert.equal(updated.defaultThreadEnvMode, "worktree");
283
284 const byId = yield* service.getById(projectId);
285 const byWorkspace = yield* service.getByWorkspaceRoot("/work/project/");
286 assert.isTrue(Option.isSome(byId));
287 assert.isTrue(Option.isSome(byWorkspace));
288 assert.equal(Option.getOrThrow(byWorkspace).id, projectId);
289 assert.isTrue(Option.getOrThrow(byId).autoPull);
290 assert.deepEqual(Option.getOrThrow(byId).projectIcon, updated.projectIcon);
291 assert.equal(Option.getOrThrow(byId).faviconPath, updated.faviconPath);
292 assert.equal(Option.getOrThrow(byId).defaultThreadEnvMode, "worktree");
293 const reset = yield* service.update({
294 commandId: CommandId.make("command:project:reset-appearance"),
295 projectId,
296 autoPull: false,
297 projectIcon: null,
298 faviconPath: null,
299 defaultThreadEnvMode: null,
300 });
301 assert.isFalse(reset.autoPull);
302 assert.isNull(reset.projectIcon);
303 assert.equal(reset.faviconPath, hydratedCreated.faviconPath);
304 assert.isNull(reset.defaultThreadEnvMode);
305 assert.deepEqual(
306 (yield* service.snapshot).projects.map((project) => project.id),
307 [projectId],
308 );
309
310 const deleted = yield* service.delete({
311 commandId: CommandId.make("command:project:delete"),
312 projectId,
313 });
314 assert.isNotNull(deleted.deletedAt);
315 assert.isTrue(Option.isNone(yield* service.getById(projectId)));
316 assert.isTrue(Option.isSome(yield* service.getById(projectId, { includeDeleted: true })));
317 assert.deepEqual((yield* service.snapshot).projects, []);
318
319 const sql = yield* SqlClient.SqlClient;
320 const changes = yield* sql<{ readonly event_type: string }>`
321 SELECT event_type
322 FROM orchestration_events
323 WHERE aggregate_kind = 'project' AND stream_id = ${projectId}
324 ORDER BY sequence ASC
325 `;
326 assert.deepEqual(
327 changes.map((change) => change.event_type),
328 ["project.created", "project.meta-updated", "project.meta-updated", "project.deleted"],
329 );
330 }),
331 );
332
333 it.effect("records the outcome and duration of a committed project command", () =>
334 Effect.gen(function* () {
335 const service = yield* ProjectService.ProjectService;
336 const successes = Metric.value(
337 Metric.withAttributes(orchestrationCommandsTotal, {
338 commandType: "project.create",
339 outcome: "success",
340 }),
341 );
342 const durations = Metric.value(
343 Metric.withAttributes(orchestrationCommandDuration, { commandType: "project.create" }),
344 );
345 const successesBefore = (yield* successes).count;
346 const durationsBefore = (yield* durations).count;
347
348 yield* service.create({
349 commandId: CommandId.make("command:metrics:create"),
350 projectId: ProjectId.make("project:metrics"),
351 title: "Metrics",
352 workspaceRoot: "/work/metrics",
353 });
354
355 assert.strictEqual((yield* successes).count - successesBefore, 1);
356 assert.strictEqual((yield* durations).count - durationsBefore, 1);
357 }),
358 );
359
360 it.effect("auto-bootstraps a workspace exactly once", () =>
361 Effect.gen(function* () {
362 const service = yield* ProjectService.ProjectService;
363 yield* TestClock.setTime(Date.parse("2026-06-20T10:00:00.000Z"));
364 const input = {
365 commandId: CommandId.make("command:bootstrap:first"),
366 projectId: ProjectId.make("project:bootstrap"),
367 title: "Bootstrap",
368 workspaceRoot: "/work/bootstrap/",
369 };
370 const first = yield* service.bootstrap(input);
371 const second = yield* service.bootstrap({
372 ...input,
373 commandId: CommandId.make("command:bootstrap:second"),
374 projectId: ProjectId.make("project:bootstrap:unused"),
375 });
376 assert.isTrue(first.created);
377 assert.isFalse(second.created);
378 assert.equal(second.project.id, first.project.id);
379 }),
380 );
381
382 it.effect("commits the event, the row and the receipt together, once per command id", () =>
383 Effect.gen(function* () {
384 const service = yield* ProjectService.ProjectService;
385 const sql = yield* SqlClient.SqlClient;
386 const projectId = ProjectId.make("project:retry");
387 const input = {
388 commandId: CommandId.make("command:retry:create"),
389 projectId,
390 title: "Retry",
391 workspaceRoot: "/work/retry",
392 };
393 const first = yield* service.create(input);
394 const retried = yield* service.create(input);
395 assert.deepEqual(retried, first);
396 const updateInput = {
397 commandId: CommandId.make("command:retry:update"),
398 projectId,
399 autoPull: true,
400 };
401 yield* service.update(updateInput);
402 yield* service.update(updateInput);
403
404 const committed = yield* sql<{
405 readonly sequence: number;
406 readonly event_type: string;
407 readonly receipt_sequence: number;
408 readonly status: string;
409 readonly aggregate_kind: string;
410 }>`
411 SELECT events.sequence, events.event_type,
412 receipts.result_sequence AS receipt_sequence, receipts.status, receipts.aggregate_kind
413 FROM orchestration_events AS events
414 JOIN orchestration_command_receipts AS receipts ON receipts.command_id = events.command_id
415 WHERE events.stream_id = ${projectId}
416 ORDER BY events.sequence
417 `;
418 assert.deepEqual(
419 committed.map((row) => [row.event_type, row.status, row.aggregate_kind]),
420 [
421 ["project.created", "accepted", "project"],
422 ["project.meta-updated", "accepted", "project"],
423 ],
424 );
425 for (const row of committed) assert.equal(row.receipt_sequence, row.sequence);
426 assert.isTrue(Option.getOrThrow(yield* service.getById(projectId)).autoPull);
427 }),
428 );
429
430 it.effect("replays a rejected receipt instead of re-planning the command", () =>
431 Effect.gen(function* () {
432 const service = yield* ProjectService.ProjectService;
433 const sql = yield* SqlClient.SqlClient;
434 const projectId = ProjectId.make("project:rejected");
435 yield* service.create({
436 commandId: CommandId.make("command:rejected:create"),
437 projectId,
438 title: "Rejected",
439 workspaceRoot: "/work/rejected",
440 });
441 const invalid = {
442 commandId: CommandId.make("command:rejected:script"),
443 projectId,
444 scripts: [
445 {
446 id: "Not.Valid",
447 name: "Invalid",
448 command: "true",
449 icon: "play" as const,
450 runOnWorktreeCreate: false,
451 },
452 ],
453 };
454 const first = yield* service.update(invalid).pipe(Effect.flip);
455 assert.equal(first._tag, "ProjectInvalidError");
456 assert.include(first.message, "Script IDs must be 1-24 lowercase letters");
457 const replayed = yield* service
458 .update({ ...invalid, scripts: [{ ...invalid.scripts[0]!, id: "valid" }] })
459 .pipe(Effect.flip);
460 assert.deepEqual(replayed, first);
461 const receipts = yield* sql<{ readonly status: string; readonly aggregate_id: string }>`
462 SELECT status, aggregate_id FROM orchestration_command_receipts
463 WHERE command_id = ${invalid.commandId}
464 `;
465 assert.deepEqual(receipts, [{ status: "rejected", aggregate_id: projectId }]);
466 const events = yield* sql`
467 SELECT sequence FROM orchestration_events WHERE command_id = ${invalid.commandId}
468 `;
469 assert.deepEqual(events, []);
470 assert.deepEqual(Option.getOrThrow(yield* service.getById(projectId)).scripts, []);
471 }),
472 );
473
474 it.effect("rejects a workspace another active project holds", () =>
475 Effect.gen(function* () {
476 const service = yield* ProjectService.ProjectService;
477 const other = ProjectId.make("project:conflict:mover");
478 yield* service.create({
479 commandId: CommandId.make("command:conflict:holder"),
480 projectId: ProjectId.make("project:conflict:holder"),
481 title: "Holder",
482 workspaceRoot: "/work/conflict",
483 });
484 yield* service.create({
485 commandId: CommandId.make("command:conflict:mover"),
486 projectId: other,
487 title: "Mover",
488 workspaceRoot: "/work/conflict-mover",
489 });
490 const move = yield* service
491 .update({
492 commandId: CommandId.make("command:conflict:move"),
493 projectId: other,
494 workspaceRoot: "/work/conflict",
495 })
496 .pipe(Effect.flip);
497 assert.equal(move._tag, "ProjectConflictError");
498 assert.equal(
499 Option.getOrThrow(yield* service.getById(other)).workspaceRoot,
500 "/work/conflict-mover",
501 );
502 }),
503 );
504
505 it.effect("replays a workspace conflict after the workspace frees up", () =>
506 Effect.gen(function* () {
507 const service = yield* ProjectService.ProjectService;
508 const holderId = ProjectId.make("project:freed:holder");
509 yield* service.create({
510 commandId: CommandId.make("command:freed:holder"),
511 projectId: holderId,
512 title: "Holder",
513 workspaceRoot: "/work/freed",
514 });
515 const claim = {
516 commandId: CommandId.make("command:freed:claim"),
517 projectId: ProjectId.make("project:freed:claim"),
518 title: "Claim",
519 workspaceRoot: "/work/freed",
520 };
521 const first = yield* service.create(claim).pipe(Effect.flip);
522 yield* service.delete({
523 commandId: CommandId.make("command:freed:delete"),
524 projectId: holderId,
525 });
526 const replayed = yield* service.create(claim).pipe(Effect.flip);
527 assert.deepEqual(replayed, first);
528 assert.instanceOf(replayed, ProjectService.ProjectConflictError);
529 assert.isTrue(
530 Option.isNone(yield* service.getById(claim.projectId, { includeDeleted: true })),
531 );
532 }),
533 );
534
535 it.effect("returns the deleted project when a completed delete is retried", () =>
536 Effect.gen(function* () {
537 const service = yield* ProjectService.ProjectService;
538 const sql = yield* SqlClient.SqlClient;
539 const projectId = ProjectId.make("project:delete-retry");
540 yield* service.create({
541 commandId: CommandId.make("command:delete-retry:create"),
542 projectId,
543 title: "Delete retry",
544 workspaceRoot: "/work/delete-retry",
545 });
546 const input = { commandId: CommandId.make("command:delete-retry:delete"), projectId };
547 const deleted = yield* service.delete(input);
548 assert.deepEqual(yield* service.delete(input), deleted);
549 const events = yield* sql<{ readonly command_id: string }>`
550 SELECT command_id FROM orchestration_events
551 WHERE stream_id = ${projectId} AND event_type = 'project.deleted'
552 `;
553 assert.deepEqual(events, [{ command_id: input.commandId }]);
554 }),
555 );
556
557 it.effect("treats a deleted project as missing for updates and new deletes", () =>
558 Effect.gen(function* () {
559 const service = yield* ProjectService.ProjectService;
560 const sql = yield* SqlClient.SqlClient;
561 const projectId = ProjectId.make("project:deleted-target");
562 yield* service.create({
563 commandId: CommandId.make("command:deleted-target:create"),
564 projectId,
565 title: "Deleted target",
566 workspaceRoot: "/work/deleted-target",
567 });
568 yield* service.delete({
569 commandId: CommandId.make("command:deleted-target:delete"),
570 projectId,
571 });
572 const again = yield* service
573 .delete({ commandId: CommandId.make("command:deleted-target:delete-again"), projectId })
574 .pipe(Effect.flip);
575 assert.instanceOf(again, ProjectService.ProjectNotFoundError);
576 const events = yield* sql<{ readonly event_type: string }>`
577 SELECT event_type FROM orchestration_events
578 WHERE stream_id = ${projectId} ORDER BY sequence ASC
579 `;
580 assert.deepEqual(
581 events.map((event) => event.event_type),
582 ["project.created", "project.deleted"],
583 );
584 }),
585 );
586
587 it.effect("rolls back the event and receipt when the row write fails", () =>
588 Effect.gen(function* () {
589 const service = yield* ProjectService.ProjectService;
590 const sql = yield* SqlClient.SqlClient;
591 const projectId = ProjectId.make("project:atomic");
592 yield* sql`
593 CREATE TRIGGER fail_project_row BEFORE INSERT ON projection_projects
594 WHEN NEW.project_id = 'project:atomic'
595 BEGIN SELECT RAISE(ABORT, 'injected row failure'); END
596 `;
597 const input = {
598 commandId: CommandId.make("command:atomic:create"),
599 projectId,
600 title: "Atomic",
601 workspaceRoot: "/work/atomic",
602 };
603 const failure = yield* service.create(input).pipe(Effect.flip);
604 assert.equal(failure._tag, "ProjectOperationError");
605 const leftovers = yield* sql<{ readonly count: number }>`
606 SELECT
607 (SELECT COUNT(*) FROM orchestration_events WHERE command_id = ${input.commandId}) +
608 (SELECT COUNT(*) FROM orchestration_command_receipts WHERE command_id = ${input.commandId}) +
609 (SELECT COUNT(*) FROM projection_projects WHERE project_id = ${projectId}) AS count
610 `;
611 assert.equal(leftovers[0]?.count, 0);
612 yield* sql`DROP TRIGGER fail_project_row`;
613 assert.equal((yield* service.create(input)).id, projectId);
614 }),
615 );
616});
617
618it.effect("keeps project snapshots available when optional metadata enrichment fails", () =>
619 Effect.gen(function* () {
620 const layerFailingMetadata = Layer.merge(
621 Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
622 resolve: () => Effect.succeed(null),
623 }),
624 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
625 invalidate: () => Effect.void,
626 resolvePath: (workspaceRoot) =>
627 Effect.fail(
628 new ProjectFaviconResolver.ProjectFaviconResolutionError({
629 operation: "stat-candidate",
630 workspaceRoot,
631 cause: "permission denied",
632 }),
633 ),
634 }),
635 );
636
637 yield* Effect.gen(function* () {
638 const service = yield* ProjectService.ProjectService;
639 const projectId = ProjectId.make("project:failed-enrichment");
640 yield* service.create({
641 commandId: CommandId.make("command:failed-enrichment:create"),
642 projectId,
643 title: "Still visible",
644 workspaceRoot: "/work/failed-enrichment",
645 });
646
647 const snapshot = yield* service.snapshot;
648 assert.equal(snapshot.projects.length, 1);
649 assert.equal(snapshot.projects[0]?.id, projectId);
650 assert.equal(snapshot.projects[0]?.title, "Still visible");
651 assert.isNull(snapshot.projects[0]?.repositoryIdentity ?? null);
652 assert.isNull(snapshot.projects[0]?.faviconPath ?? null);
653 }).pipe(Effect.provide(layerTestFor(layerFailingMetadata)));
654 }),
655);
656
657it.effect("invalidates workspace-derived metadata when a project moves", () =>
658 Effect.gen(function* () {
659 const metadataVersion = yield* Ref.make(1);
660 const layerVersionedMetadata = Layer.merge(
661 Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
662 resolve: (workspaceRoot) =>
663 Ref.get(metadataVersion).pipe(
664 Effect.map((version) => ({
665 canonicalKey: `example.test/v${version}${workspaceRoot}`,
666 locator: {
667 source: "git-remote" as const,
668 remoteName: "origin",
669 remoteUrl: `https://example.test/v${version}${workspaceRoot}.git`,
670 },
671 rootPath: workspaceRoot,
672 })),
673 ),
674 }),
675 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
676 invalidate: () => Effect.void,
677 resolvePath: (workspaceRoot) =>
678 Ref.get(metadataVersion).pipe(
679 Effect.map((version) => `${workspaceRoot}/favicon-v${version}.svg`),
680 ),
681 }),
682 );
683
684 yield* Effect.gen(function* () {
685 const service = yield* ProjectService.ProjectService;
686 const projectId = ProjectId.make("project:moved-enrichment");
687 yield* service.create({
688 commandId: CommandId.make("command:moved-enrichment:create"),
689 projectId,
690 title: "Moved",
691 workspaceRoot: "/work/original",
692 });
693 assert.equal(
694 (yield* waitForProject(
695 service,
696 projectId,
697 (project) => project.faviconPath === "/work/original/favicon-v1.svg",
698 )).faviconPath,
699 "/work/original/favicon-v1.svg",
700 );
701
702 yield* Ref.set(metadataVersion, 2);
703 yield* service.update({
704 commandId: CommandId.make("command:moved-enrichment:away"),
705 projectId,
706 workspaceRoot: "/work/temporary",
707 });
708 yield* service.snapshot;
709
710 yield* Ref.set(metadataVersion, 3);
711 yield* service.update({
712 commandId: CommandId.make("command:moved-enrichment:return"),
713 projectId,
714 workspaceRoot: "/work/original",
715 });
716 assert.equal(
717 (yield* waitForProject(
718 service,
719 projectId,
720 (project) => project.faviconPath === "/work/original/favicon-v3.svg",
721 )).faviconPath,
722 "/work/original/favicon-v3.svg",
723 );
724 }).pipe(Effect.provide(layerTestFor(layerVersionedMetadata)));
725 }),
726);
727
728it.effect("serializes two projects claiming the same workspace root", () =>
729 Effect.gen(function* () {
730 const eventSink = yield* EventSink.EventSinkV2;
731 const firstReachedCommit = yield* Deferred.make<void>();
732 const releaseFirst = yield* Deferred.make<void>();
733 const gatedSink = EventSink.EventSinkV2.of({
734 ...eventSink,
735 commitProjectCommand: (input) =>
736 input.projectId === "project:race:first"
737 ? Deferred.succeed(firstReachedCommit, undefined).pipe(
738 Effect.andThen(Deferred.await(releaseFirst)),
739 Effect.andThen(eventSink.commitProjectCommand(input)),
740 )
741 : eventSink.commitProjectCommand(input),
742 });
743 const service = yield* ProjectService.make.pipe(
744 Effect.provideService(EventSink.EventSinkV2, gatedSink),
745 );
746 const claim = (name: string) =>
747 service.create({
748 commandId: CommandId.make(`command:race:${name}`),
749 projectId: ProjectId.make(`project:race:${name}`),
750 title: name,
751 workspaceRoot: "/work/race",
752 });
753 const first = yield* claim("first").pipe(Effect.forkChild({ startImmediately: true }));
754 yield* Deferred.await(firstReachedCommit);
755 const second = yield* claim("second").pipe(
756 Effect.flip,
757 Effect.forkChild({ startImmediately: true }),
758 );
759 yield* Effect.yieldNow;
760 assert.isUndefined(second.pollUnsafe());
761 yield* Deferred.succeed(releaseFirst, undefined);
762 assert.equal((yield* Fiber.join(first)).id, "project:race:first");
763 assert.equal((yield* Fiber.join(second))._tag, "ProjectConflictError");
764 }).pipe(Effect.provide(layerProjectServiceDependencies)),
765);
766
767it.effect("rejects an update that waited on the lock while its project was deleted", () =>
768 Effect.gen(function* () {
769 const eventSink = yield* EventSink.EventSinkV2;
770 const deleteReachedCommit = yield* Deferred.make<void>();
771 const releaseDelete = yield* Deferred.make<void>();
772 const gatedSink = EventSink.EventSinkV2.of({
773 ...eventSink,
774 commitProjectCommand: (input) =>
775 input.commandType === "project.delete"
776 ? Deferred.succeed(deleteReachedCommit, undefined).pipe(
777 Effect.andThen(Deferred.await(releaseDelete)),
778 Effect.andThen(eventSink.commitProjectCommand(input)),
779 )
780 : eventSink.commitProjectCommand(input),
781 });
782 const service = yield* ProjectService.make.pipe(
783 Effect.provideService(EventSink.EventSinkV2, gatedSink),
784 );
785 const sql = yield* SqlClient.SqlClient;
786 const projectId = ProjectId.make("project:update-race");
787 yield* service.create({
788 commandId: CommandId.make("command:update-race:create"),
789 projectId,
790 title: "Update race",
791 workspaceRoot: "/work/update-race",
792 });
793 const deletion = yield* service
794 .delete({ commandId: CommandId.make("command:update-race:delete"), projectId })
795 .pipe(Effect.forkChild({ startImmediately: true }));
796 yield* Deferred.await(deleteReachedCommit);
797 const updateCommandId = CommandId.make("command:update-race:update");
798 const update = yield* service
799 .update({ commandId: updateCommandId, projectId, title: "Too late" })
800 .pipe(Effect.flip, Effect.forkChild({ startImmediately: true }));
801 yield* Effect.yieldNow;
802 yield* Deferred.succeed(releaseDelete, undefined);
803 assert.isNotNull((yield* Fiber.join(deletion)).deletedAt);
804 assert.instanceOf(yield* Fiber.join(update), ProjectService.ProjectNotFoundError);
805 const receipts = yield* sql<{ readonly status: string }>`
806 SELECT status FROM orchestration_command_receipts WHERE command_id = ${updateCommandId}
807 `;
808 assert.deepEqual(receipts, [{ status: "rejected" }]);
809 const events = yield* sql<{ readonly event_type: string }>`
810 SELECT event_type FROM orchestration_events
811 WHERE stream_id = ${projectId} ORDER BY sequence ASC
812 `;
813 assert.deepEqual(
814 events.map((event) => event.event_type),
815 ["project.created", "project.deleted"],
816 );
817 assert.equal(
818 Option.getOrThrow(yield* service.getById(projectId, { includeDeleted: true })).title,
819 "Update race",
820 );
821 }).pipe(Effect.provide(layerProjectServiceDependencies)),
822);