252 lines
11 KiB
TypeScript
252 lines
11 KiB
TypeScript
import { mkdtemp, rm } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { tmpdir } from "node:os";
|
|
import { DatabaseSync } from "node:sqlite";
|
|
import { afterEach, describe, expect, it } from "vitest";
|
|
import { AppDatabase } from "../../src/main/database";
|
|
import type { WorkProductType } from "../../src/shared/types";
|
|
|
|
const tempDirs: string[] = [];
|
|
|
|
async function createTempDir(prefix: string) {
|
|
const dir = await mkdtemp(join(tmpdir(), prefix));
|
|
tempDirs.push(dir);
|
|
return dir;
|
|
}
|
|
|
|
afterEach(async () => {
|
|
await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
|
|
});
|
|
|
|
async function createHarness() {
|
|
const profileDir = await createTempDir("agentcompany-primary-wp-");
|
|
const db = new AppDatabase(profileDir);
|
|
db.init();
|
|
const companyId = db.core.company.saveCompany({
|
|
name: "Primary Work Product Co",
|
|
description: "Tests primary invariant",
|
|
status: "active",
|
|
});
|
|
const agentId = db.core.agents.saveAgent({
|
|
companyId,
|
|
name: "Writer",
|
|
role: "Engineer",
|
|
title: "Writer",
|
|
status: "active",
|
|
reportsTo: null,
|
|
connectorId: "openai-codex",
|
|
model: null,
|
|
capabilities: "Writes artifacts",
|
|
budgetMonthlyUsd: 100,
|
|
});
|
|
const taskId = db.core.tasks.saveTask({
|
|
companyId,
|
|
title: "Create deliverables",
|
|
description: "",
|
|
assigneeAgentId: agentId,
|
|
priority: "medium",
|
|
status: "in_progress",
|
|
});
|
|
return { db, companyId, taskId };
|
|
}
|
|
|
|
function createWorkProduct(db: AppDatabase, companyId: string, taskId: string, title: string, isPrimary = false, type: WorkProductType = "file") {
|
|
return db.core.documents.createWorkProduct({
|
|
companyId,
|
|
taskId,
|
|
type,
|
|
provider: "filesystem",
|
|
externalId: `${title}.md`,
|
|
title,
|
|
isPrimary,
|
|
});
|
|
}
|
|
|
|
function listPrimaryIds(db: AppDatabase, companyId: string, taskId: string) {
|
|
return listPrimaryIdsByType(db, companyId, taskId, "file");
|
|
}
|
|
|
|
function listPrimaryIdsByType(db: AppDatabase, companyId: string, taskId: string, type: string) {
|
|
return db.queryAll<{ id: string }>(
|
|
"select id from work_products where company_id = ? and task_id = ? and type = ? and is_primary = 1 and status <> 'archived' order by updated_at desc",
|
|
companyId,
|
|
taskId,
|
|
type,
|
|
).map((row) => row.id);
|
|
}
|
|
|
|
describe("work product primary invariant", () => {
|
|
it("installs the database unique index for active primary rows", async () => {
|
|
const { db } = await createHarness();
|
|
try {
|
|
const index = db.queryAll<{ sql: string | null }>(
|
|
"select sql from sqlite_master where type = 'index' and name = 'idx_work_products_primary_active' limit 1",
|
|
)[0];
|
|
expect(index?.sql).toContain("ON work_products(company_id, task_id, type)");
|
|
expect(index?.sql).toContain("is_primary = 1");
|
|
expect(index?.sql).toContain("status <> 'archived'");
|
|
} finally {
|
|
db.close();
|
|
}
|
|
});
|
|
|
|
it("normalizes duplicate active primaries during v56 migration", async () => {
|
|
const profileDir = await createTempDir("agentcompany-primary-migration-");
|
|
const dbPath = join(profileDir, "profile.sqlite");
|
|
const rawDb = new DatabaseSync(dbPath);
|
|
const ts = "2026-04-24T00:00:00.000Z";
|
|
try {
|
|
rawDb.exec(`
|
|
create table settings (key text primary key, value text not null);
|
|
create table companies (id text primary key, name text not null, description text not null, status text not null, created_at text not null, updated_at text not null);
|
|
create table agents (id text primary key, company_id text not null, status text not null, reports_to text, department text, connector_id text not null default 'openai-codex', updated_at text not null);
|
|
create table tasks (
|
|
id text primary key,
|
|
company_id text not null,
|
|
title text not null,
|
|
description text not null,
|
|
status text not null,
|
|
priority text not null,
|
|
created_at text not null,
|
|
updated_at text not null
|
|
);
|
|
create table workspaces (id text primary key, company_id text not null, local_path text not null, state text not null, lock_holder_run_id text, lock_acquired_at text, updated_at text not null);
|
|
create table agent_messages (id text primary key, company_id text not null, channel text not null, channel_target_id text, created_at text not null);
|
|
create table model_capabilities (
|
|
provider TEXT NOT NULL,
|
|
model_id TEXT NOT NULL,
|
|
reasoning INTEGER NOT NULL,
|
|
coding INTEGER NOT NULL,
|
|
writing INTEGER NOT NULL,
|
|
tier TEXT NOT NULL,
|
|
cost_per_mtok_out REAL NOT NULL,
|
|
updated_at TEXT NOT NULL,
|
|
PRIMARY KEY (provider, model_id)
|
|
);
|
|
create table work_products (
|
|
id TEXT PRIMARY KEY,
|
|
company_id TEXT NOT NULL,
|
|
project_id TEXT,
|
|
task_id TEXT,
|
|
workspace_id TEXT,
|
|
type TEXT NOT NULL,
|
|
provider TEXT NOT NULL,
|
|
external_id TEXT,
|
|
title TEXT NOT NULL,
|
|
url TEXT,
|
|
status TEXT NOT NULL DEFAULT 'active',
|
|
review_state TEXT NOT NULL DEFAULT 'none',
|
|
is_primary INTEGER NOT NULL DEFAULT 0,
|
|
summary TEXT,
|
|
metadata_json TEXT,
|
|
created_by_run_id TEXT,
|
|
last_touched_by_run_id TEXT,
|
|
created_at TEXT NOT NULL,
|
|
updated_at TEXT NOT NULL,
|
|
FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
|
|
);
|
|
create table schema_migrations (version integer primary key, name text not null, applied_at text not null);
|
|
`);
|
|
for (let version = 1; version <= 55; version += 1) {
|
|
rawDb
|
|
.prepare("insert into schema_migrations (version, name, applied_at) values (?, ?, ?)")
|
|
.run(version, `legacy-${version}`, ts);
|
|
}
|
|
rawDb
|
|
.prepare("insert into companies (id, name, description, status, created_at, updated_at) values (?, ?, ?, ?, ?, ?)")
|
|
.run("company-1", "Legacy Co", "", "active", ts, ts);
|
|
rawDb
|
|
.prepare("insert into tasks (id, company_id, title, description, status, priority, created_at, updated_at) values (?, ?, ?, ?, ?, ?, ?, ?)")
|
|
.run("task-1", "company-1", "Legacy task", "", "in_progress", "medium", ts, ts);
|
|
rawDb
|
|
.prepare("insert into work_products (id, company_id, task_id, type, provider, external_id, title, status, review_state, is_primary, created_at, updated_at) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
|
|
.run("older-primary", "company-1", "task-1", "file", "filesystem", "older.md", "Older", "active", "none", 1, "2026-04-24T00:00:01.000Z", "2026-04-24T00:00:01.000Z");
|
|
rawDb
|
|
.prepare("insert into work_products (id, company_id, task_id, type, provider, external_id, title, status, review_state, is_primary, created_at, updated_at) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
|
|
.run("newer-primary", "company-1", "task-1", "file", "filesystem", "newer.md", "Newer", "active", "none", 1, "2026-04-24T00:00:02.000Z", "2026-04-24T00:00:02.000Z");
|
|
} finally {
|
|
rawDb.close();
|
|
}
|
|
|
|
const appDb = new AppDatabase(profileDir);
|
|
appDb.init();
|
|
try {
|
|
expect(listPrimaryIdsByType(appDb, "company-1", "task-1", "file")).toEqual(["newer-primary"]);
|
|
const older = appDb.queryAll<{ isPrimary: number }>("select is_primary as isPrimary from work_products where id = 'older-primary'")[0];
|
|
expect(older?.isPrimary).toBe(0);
|
|
const migration = appDb.queryAll<{ version: number }>("select version from schema_migrations where version = 56")[0];
|
|
expect(migration?.version).toBe(56);
|
|
const index = appDb.queryAll<{ sql: string | null }>(
|
|
"select sql from sqlite_master where type = 'index' and name = 'idx_work_products_primary_active' limit 1",
|
|
)[0];
|
|
expect(index?.sql).toContain("idx_work_products_primary_active");
|
|
} finally {
|
|
appDb.close();
|
|
}
|
|
});
|
|
|
|
it("rejects direct SQL writes that violate the primary invariant", async () => {
|
|
const { db, companyId, taskId } = await createHarness();
|
|
try {
|
|
createWorkProduct(db, companyId, taskId, "first", true);
|
|
expect(() => db.queryAll(
|
|
`insert into work_products (
|
|
id, company_id, task_id, type, provider, external_id, title, status, review_state, is_primary, created_at, updated_at
|
|
) values (
|
|
'direct-primary', ?, ?, 'file', 'filesystem', 'direct.md', 'Direct', 'active', 'none', 1, '2026-04-24T00:00:00.000Z', '2026-04-24T00:00:00.000Z'
|
|
)`,
|
|
companyId,
|
|
taskId,
|
|
)).toThrow(/UNIQUE constraint failed/);
|
|
} finally {
|
|
db.close();
|
|
}
|
|
});
|
|
|
|
it("moves primary status when PATCH promotes another work product", async () => {
|
|
const { db, companyId, taskId } = await createHarness();
|
|
try {
|
|
const firstId = createWorkProduct(db, companyId, taskId, "first", true);
|
|
const secondId = createWorkProduct(db, companyId, taskId, "second", false);
|
|
|
|
db.core.documents.updateWorkProduct(secondId, companyId, { isPrimary: true });
|
|
|
|
expect(listPrimaryIds(db, companyId, taskId)).toEqual([secondId]);
|
|
const first = db.queryAll<{ isPrimary: number }>("select is_primary as isPrimary from work_products where id = ?", firstId)[0];
|
|
expect(first?.isPrimary).toBe(0);
|
|
} finally {
|
|
db.close();
|
|
}
|
|
});
|
|
|
|
it("keeps the primary invariant when create inserts a new primary", async () => {
|
|
const { db, companyId, taskId } = await createHarness();
|
|
try {
|
|
const firstId = createWorkProduct(db, companyId, taskId, "first", true);
|
|
const secondId = createWorkProduct(db, companyId, taskId, "second", true);
|
|
|
|
expect(listPrimaryIds(db, companyId, taskId)).toEqual([secondId]);
|
|
const first = db.queryAll<{ isPrimary: number }>("select is_primary as isPrimary from work_products where id = ?", firstId)[0];
|
|
expect(first?.isPrimary).toBe(0);
|
|
} finally {
|
|
db.close();
|
|
}
|
|
});
|
|
|
|
it("moves primary status when a primary work product changes type", async () => {
|
|
const { db, companyId, taskId } = await createHarness();
|
|
try {
|
|
const firstId = createWorkProduct(db, companyId, taskId, "first", true, "file");
|
|
const secondId = createWorkProduct(db, companyId, taskId, "second", true, "link");
|
|
|
|
db.core.documents.updateWorkProduct(firstId, companyId, { type: "link" });
|
|
|
|
expect(listPrimaryIdsByType(db, companyId, taskId, "link")).toEqual([firstId]);
|
|
const second = db.queryAll<{ isPrimary: number }>("select is_primary as isPrimary from work_products where id = ?", secondId)[0];
|
|
expect(second?.isPrimary).toBe(0);
|
|
} finally {
|
|
db.close();
|
|
}
|
|
});
|
|
});
|