Hare/yoi
1
1
Fork 0
Code Actions Packages Releases Activity

feat: add shared Workspace Ticket classification tags

Browse Source
This commit is contained in:
Hare
2026-10-11 01:23:30 +09:00
parent 6a12b6cc34
commit e9397fa0dd
29 changed files with 3959 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/ticket/src/latest_schema.sql
+38
View File
@@ -131,3 +131,41 @@ CREATE INDEX typed_tickets_workspace_title
ON typed_tickets(workspace_id, title COLLATE NOCASE, ticket_id);
CREATE INDEX typed_tickets_workspace_updated
ON typed_tickets(workspace_id, updated_at DESC, ticket_id);
-- Workspace tag foundation (v8): shared by fresh schema and v7 upgrade.
CREATE TABLE workspace_tags (
workspace_id TEXT NOT NULL,
tag_id TEXT NOT NULL,
name TEXT NOT NULL,
normalized_name TEXT NOT NULL,
last_operation_key TEXT NOT NULL,
deleted INTEGER NOT NULL CHECK (deleted IN (0, 1)),
PRIMARY KEY (workspace_id, tag_id)
);
CREATE UNIQUE INDEX workspace_tags_active_name
ON workspace_tags(workspace_id, normalized_name) WHERE deleted = 0;
CREATE TABLE typed_ticket_tags (
workspace_id TEXT NOT NULL,
ticket_id TEXT NOT NULL,
tag_id TEXT NOT NULL,
PRIMARY KEY (workspace_id, ticket_id, tag_id),
FOREIGN KEY (workspace_id, ticket_id) REFERENCES typed_tickets(workspace_id, ticket_id) ON DELETE CASCADE,
FOREIGN KEY (workspace_id, tag_id) REFERENCES workspace_tags(workspace_id, tag_id) ON DELETE RESTRICT
);
CREATE INDEX typed_ticket_tags_workspace_tag
ON typed_ticket_tags(workspace_id, tag_id, ticket_id);
-- Immutable operation receipt and Workspace audit: exact input includes actor
-- attributes; before/result preserve stable identities and display-name snapshots.
-- No foreign keys to mutable rows: history survives deletion of current links.
CREATE TABLE workspace_tag_operations (
workspace_id TEXT NOT NULL,
operation_key TEXT NOT NULL,
kind TEXT NOT NULL,
target_id TEXT NOT NULL,
input_json TEXT NOT NULL,
source_context_json TEXT NOT NULL,
before_json TEXT NOT NULL,
result_json TEXT NOT NULL,
at TEXT NOT NULL,
PRIMARY KEY (workspace_id, operation_key)
);
crates/ticket/src/lib.rs
+69 -3
View File
@@ -22,9 +22,16 @@ use thiserror::Error;
pub mod config;
mod sqlite_schema;
mod tags;
pub use tags::{
TagListRequest, TicketTagSetRequest, WorkspaceTag, WorkspaceTagAction, WorkspaceTagMutation,
};
pub mod tool;
pub use sqlite_schema::{migrate_sqlite_ticket_schema, verify_sqlite_ticket_schema};
pub use sqlite_schema::{
migrate_sqlite_ticket_schema, verify_pre_classification_ticket_schema,
verify_sqlite_ticket_schema,
};
const MAX_INTAKE_SUMMARY_BODY_BYTES: usize = 16 * 1024;
const MAX_ORCHESTRATION_PLAN_TEXT_BYTES: usize = 16 * 1024;
@@ -116,6 +123,7 @@ fn io_err(path: impl Into<PathBuf>, source: io::Error) -> TicketError {
fn read_ticket_summary_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<TicketSummary> {
let workflow_state = row.get::<_, String>(7)?;
Ok(TicketSummary {
tags: Vec::new(),
id: row.get(0)?,
resource_key: None,
slug: row.get(1)?,
@@ -360,6 +368,7 @@ pub enum TicketEventKind {
Decision,
ImplementationReport,
StateChanged,
TagsChanged,
IntakeSummary,
StatusChanged,
Close,
@@ -375,6 +384,7 @@ impl TicketEventKind {
Self::Decision => "decision",
Self::ImplementationReport => "implementation_report",
Self::StateChanged => "state_changed",
Self::TagsChanged => "tags_changed",
Self::IntakeSummary => "intake_summary",
Self::StatusChanged => "status_changed",
Self::Close => "close",
@@ -390,6 +400,7 @@ impl TicketEventKind {
Self::Decision => "Decision".to_string(),
Self::ImplementationReport => "Implementation report".to_string(),
Self::StateChanged => "State changed".to_string(),
Self::TagsChanged => "Tags changed".to_string(),
Self::IntakeSummary => "Intake summary".to_string(),
Self::StatusChanged => "Status changed".to_string(),
Self::Close => "Closed".to_string(),
@@ -408,6 +419,7 @@ impl From<&str> for TicketEventKind {
"implementation_report" => Self::ImplementationReport,
"review" => Self::Comment,
"state_changed" => Self::StateChanged,
"tags_changed" => Self::TagsChanged,
"intake_summary" => Self::IntakeSummary,
"status_changed" => Self::StatusChanged,
"close" | "closed" => Self::Close,
@@ -1635,6 +1647,8 @@ pub struct TicketMeta {
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
pub struct TicketSummary {
#[serde(default)]
pub tags: Vec<WorkspaceTag>,
pub id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_key: Option<String>,
@@ -1718,6 +1732,8 @@ pub struct TicketArtifactRef {
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
pub struct Ticket {
#[serde(default)]
pub tags: Vec<WorkspaceTag>,
pub meta: TicketMeta,
pub document: TicketDocument,
pub events: Vec<TicketEvent>,
@@ -1774,6 +1790,13 @@ impl TicketDoctorReport {
}
pub trait TicketBackend {
fn list_workspace_tags(&self, request: TagListRequest) -> Result<Vec<WorkspaceTag>>;
fn mutate_workspace_tag(&self, request: WorkspaceTagMutation) -> Result<WorkspaceTag>;
fn set_ticket_tags(
&self,
id: TicketIdOrSlug,
request: TicketTagSetRequest,
) -> Result<Vec<WorkspaceTag>>;
fn default_intake_ready_state_change_body(&self, from: &str) -> String;
fn list(&self, filter: TicketListQuery) -> Result<Vec<TicketSummary>>;
fn show(&self, id: TicketIdOrSlug) -> Result<Ticket>;
@@ -1848,6 +1871,16 @@ pub trait TicketBackend {
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "operation", rename_all = "snake_case")]
pub enum TicketBackendOperation {
ListWorkspaceTags {
request: TagListRequest,
},
MutateWorkspaceTag {
request: WorkspaceTagMutation,
},
SetTicketTags {
id: TicketIdOrSlug,
request: TicketTagSetRequest,
},
DefaultIntakeReadyStateChangeBody {
from: String,
},
@@ -1938,6 +1971,8 @@ pub enum TicketBackendOperation {
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "result", content = "value", rename_all = "snake_case")]
pub enum TicketBackendOperationResult {
WorkspaceTags(Vec<WorkspaceTag>),
WorkspaceTag(WorkspaceTag),
Text(String),
Unit,
Tickets(Vec<TicketSummary>),
@@ -1961,6 +1996,15 @@ where
B: TicketBackend + ?Sized,
{
Ok(match operation {
TicketBackendOperation::ListWorkspaceTags { request } => {
TicketBackendOperationResult::WorkspaceTags(backend.list_workspace_tags(request)?)
}
TicketBackendOperation::MutateWorkspaceTag { request } => {
TicketBackendOperationResult::WorkspaceTag(backend.mutate_workspace_tag(request)?)
}
TicketBackendOperation::SetTicketTags { id, request } => {
TicketBackendOperationResult::WorkspaceTags(backend.set_ticket_tags(id, request)?)
}
TicketBackendOperation::DefaultIntakeReadyStateChangeBody { from } => {
TicketBackendOperationResult::Text(
backend.default_intake_ready_state_change_body(&from),
@@ -2259,6 +2303,7 @@ impl SqliteTicketBackend {
.map_err(sqlite_err)?;
for summary in &mut summaries {
summary.resource_key = Self::resource_key_for(conn, &self.workspace_id, &summary.id)?;
summary.tags = self.load_ticket_tags(conn, &summary.id)?;
}
let has_more = summaries.len() > query.limit;
summaries.truncate(query.limit);
@@ -2343,6 +2388,7 @@ impl SqliteTicketBackend {
updated_at,
) = row.map_err(sqlite_err)?;
summaries.push(TicketSummary {
tags: self.load_ticket_tags(conn, &id)?,
resource_key: Self::resource_key_for(conn, &self.workspace_id, &id)?,
id,
slug,
@@ -2929,6 +2975,7 @@ impl SqliteTicketBackend {
let artifacts = self.load_artifacts(conn, ticket_id)?;
let relations = self.relation_view_for_meta(conn, &meta)?;
Ok(Ticket {
tags: self.load_ticket_tags(conn, ticket_id)?,
meta,
document: TicketDocument {
body: MarkdownText::new(body),
@@ -3098,7 +3145,9 @@ impl SqliteTicketBackend {
}
meta.labels =
self.load_ordered_values(conn, "typed_ticket_labels", "label", &meta.id)?;
summaries.push(ticket_summary_from_meta(meta));
let mut summary = ticket_summary_from_meta(meta);
summary.tags = self.load_ticket_tags(conn, &summary.id)?;
summaries.push(summary);
}
Ok(summaries)
}
@@ -3173,6 +3222,19 @@ fn finish_sqlite_transaction<R>(conn: &Connection, result: Result<R>) -> Result<
}
impl TicketBackend for SqliteTicketBackend {
fn list_workspace_tags(&self, request: TagListRequest) -> Result<Vec<WorkspaceTag>> {
self.list_tags(request)
}
fn mutate_workspace_tag(&self, request: WorkspaceTagMutation) -> Result<WorkspaceTag> {
self.mutate_tag(request)
}
fn set_ticket_tags(
&self,
id: TicketIdOrSlug,
request: TicketTagSetRequest,
) -> Result<Vec<WorkspaceTag>> {
self.set_tags(id, request)
}
fn default_intake_ready_state_change_body(&self, from: &str) -> String {
if is_japanese_record_language(self.record_language()) {
format!("Ticket planning が完了しました。state {from} -> ready。\n")
@@ -3253,6 +3315,7 @@ impl TicketBackend for SqliteTicketBackend {
.author
.unwrap_or_else(|| "SqliteTicketBackend".to_string());
let ticket = Ticket {
tags: Vec::new(),
meta,
document: TicketDocument {
body,
@@ -3400,7 +3463,8 @@ impl TicketBackend for SqliteTicketBackend {
let states = self.state_index(conn)?;
let relations = self.all_relations(conn)?;
let blockers = transitive_dependency_blockers(&ticket_id, &states, &relations)?;
let summary = ticket_summary_from_meta(ticket.meta);
let mut summary = ticket_summary_from_meta(ticket.meta);
summary.tags = ticket.tags;
let mut projection = project_ticket_workspace_item(&summary, &blockers, None);
projection.queue_guard = ticket_queue_guard(&summary, &blockers, None);
let queue_tickets = vec![ticket_id];
@@ -3854,6 +3918,7 @@ impl TicketBackend for SqliteTicketBackend {
fn ticket_summary_from_meta(meta: TicketMeta) -> TicketSummary {
TicketSummary {
tags: Vec::new(),
id: meta.id,
resource_key: meta.resource_key,
slug: meta.slug,
@@ -4664,6 +4729,7 @@ mod tests {
fn summary_with_state(state: TicketWorkflowState) -> TicketSummary {
TicketSummary {
tags: Vec::new(),
id: "000TEST".to_string(),
resource_key: Some("T-1".to_string()),
slug: "000TEST".to_string(),
crates/ticket/src/sqlite_schema.rs
+285 -9
View File
@@ -7,8 +7,8 @@ use crate::{Result, TicketError, sqlite_err};
const MIGRATION_TABLE: &str = "ticket_schema_migrations";
const MAX_SCHEMA_DIAGNOSTICS: usize = 32;
const LATEST_SQLITE_TICKET_SCHEMA_VERSION: i64 = 7;
const PREVIOUS_SQLITE_TICKET_SCHEMA_VERSION: i64 = 6;
const LATEST_SQLITE_TICKET_SCHEMA_VERSION: i64 = 8;
const PREVIOUS_SQLITE_TICKET_SCHEMA_VERSION: i64 = 7;
const BASELINE_MIGRATION_NAME: &str = "ticket schema baseline";
#[derive(Clone, Copy)]
@@ -41,6 +41,9 @@ struct ExpectedForeignKey {
}
const OWNED_TABLES: &[&str] = &[
"workspace_tags",
"typed_ticket_tags",
"workspace_tag_operations",
"typed_tickets",
"typed_ticket_targets",
"typed_ticket_labels",
@@ -96,6 +99,57 @@ const TICKET_COLUMNS: &[ExpectedColumn] = &[
column("resolution", "TEXT", false, 0),
];
const TAG_COLUMNS: &[ExpectedColumn] = &[
column("workspace_id", "TEXT", true, 1),
column("tag_id", "TEXT", true, 2),
column("name", "TEXT", true, 0),
column("normalized_name", "TEXT", true, 0),
column("last_operation_key", "TEXT", true, 0),
column("deleted", "INTEGER", true, 0),
];
const TICKET_TAG_COLUMNS: &[ExpectedColumn] = &[
column("workspace_id", "TEXT", true, 1),
column("ticket_id", "TEXT", true, 2),
column("tag_id", "TEXT", true, 3),
];
const TAG_OPERATION_COLUMNS: &[ExpectedColumn] = &[
column("workspace_id", "TEXT", true, 1),
column("operation_key", "TEXT", true, 2),
column("kind", "TEXT", true, 0),
column("target_id", "TEXT", true, 0),
column("input_json", "TEXT", true, 0),
column("source_context_json", "TEXT", true, 0),
column("before_json", "TEXT", true, 0),
column("result_json", "TEXT", true, 0),
column("at", "TEXT", true, 0),
];
const TICKET_TAG_FOREIGN_KEYS: &[ExpectedForeignKey] = &[
ExpectedForeignKey {
from: "workspace_id",
target_table: "typed_tickets",
to: "workspace_id",
on_delete: "CASCADE",
},
ExpectedForeignKey {
from: "ticket_id",
target_table: "typed_tickets",
to: "ticket_id",
on_delete: "CASCADE",
},
ExpectedForeignKey {
from: "workspace_id",
target_table: "workspace_tags",
to: "workspace_id",
on_delete: "RESTRICT",
},
ExpectedForeignKey {
from: "tag_id",
target_table: "workspace_tags",
to: "tag_id",
on_delete: "RESTRICT",
},
];
const TARGET_COLUMNS: &[ExpectedColumn] = &[
column("workspace_id", "TEXT", true, 1),
column("ticket_id", "TEXT", true, 2),
@@ -288,12 +342,17 @@ pub fn migrate_sqlite_ticket_schema(connection: &Connection) -> Result<()> {
PREVIOUS_SQLITE_TICKET_SCHEMA_VERSION,
BASELINE_MIGRATION_NAME.to_string(),
)])
|| applied == BTreeMap::from([(6, BASELINE_MIGRATION_NAME.to_string())])
{
migrate_v6_to_v7(connection)?;
let previous = *applied.keys().next().expect("one migration");
if previous == 6 {
migrate_v6_to_v7(connection)?;
}
migrate_v7_to_v8(connection)?;
connection
.execute(
"DELETE FROM ticket_schema_migrations WHERE version = ?1",
params![PREVIOUS_SQLITE_TICKET_SCHEMA_VERSION],
params![previous],
)
.map_err(sqlite_err)?;
connection
@@ -325,6 +384,17 @@ pub fn migrate_sqlite_ticket_schema(connection: &Connection) -> Result<()> {
/// Verifies the current Ticket-owned SQLite schema without executing DDL.
pub fn verify_sqlite_ticket_schema(connection: &Connection) -> Result<()> {
verify_ticket_schema_shape(connection, false)
}
/// Retained Workspace schema-66 migration produces the pre-classification v7
/// Ticket shape. Validate that intermediate contract before the normal startup
/// path upgrades it; never require future tag tables inside that old transaction.
pub fn verify_pre_classification_ticket_schema(connection: &Connection) -> Result<()> {
verify_ticket_schema_shape(connection, true)
}
fn verify_ticket_schema_shape(connection: &Connection, pre_classification: bool) -> Result<()> {
let mut diagnostics = Vec::new();
collect_table_diagnostics(
@@ -337,7 +407,18 @@ pub fn verify_sqlite_ticket_schema(connection: &Connection) -> Result<()> {
match load_applied_migrations(connection) {
Ok(applied) => {
if let Err(error) = validate_applied_migrations(&applied) {
let history = if pre_classification {
if applied == BTreeMap::from([(7, BASELINE_MIGRATION_NAME.to_owned())]) {
Ok(())
} else {
Err(TicketError::Sqlite(
"pre-classification schema requires the retained v7 baseline".into(),
))
}
} else {
validate_applied_migrations(&applied)
};
if let Err(error) = history {
push_diagnostic(&mut diagnostics, error.to_string());
} else if applied.len() != MIGRATIONS.len() {
push_diagnostic(
@@ -354,6 +435,17 @@ pub fn verify_sqlite_ticket_schema(connection: &Connection) -> Result<()> {
}
for (table, columns, foreign_keys) in [
("workspace_tags", TAG_COLUMNS, TICKET_FOREIGN_KEYS),
(
"typed_ticket_tags",
TICKET_TAG_COLUMNS,
TICKET_TAG_FOREIGN_KEYS,
),
(
"workspace_tag_operations",
TAG_OPERATION_COLUMNS,
TICKET_FOREIGN_KEYS,
),
("typed_tickets", TICKET_COLUMNS, TICKET_FOREIGN_KEYS),
("typed_ticket_targets", TARGET_COLUMNS, CHILD_FOREIGN_KEYS),
("typed_ticket_labels", LABEL_COLUMNS, CHILD_FOREIGN_KEYS),
@@ -394,9 +486,47 @@ pub fn verify_sqlite_ticket_schema(connection: &Connection) -> Result<()> {
CHILD_FOREIGN_KEYS,
),
] {
if pre_classification
&& matches!(
table,
"workspace_tags" | "typed_ticket_tags" | "workspace_tag_operations"
)
{
continue;
}
collect_table_diagnostics(connection, table, columns, foreign_keys, &mut diagnostics);
}
if !pre_classification {
collect_index_diagnostics(
connection,
"workspace_tags",
Some("workspace_tags_active_name"),
true,
&["workspace_id", "normalized_name"],
&mut diagnostics,
);
collect_index_diagnostics(
connection,
"typed_ticket_tags",
Some("typed_ticket_tags_workspace_tag"),
false,
&["workspace_id", "tag_id", "ticket_id"],
&mut diagnostics,
);
let tag_name_index_sql: Option<String> = connection.query_row("SELECT sql FROM sqlite_master WHERE type='index' AND name='workspace_tags_active_name'", [], |row| row.get(0)).optional().map_err(sqlite_err)?;
if !tag_name_index_sql.is_some_and(|sql| {
sql.split_whitespace()
.collect::<String>()
.to_lowercase()
.ends_with("wheredeleted=0")
}) {
push_diagnostic(
&mut diagnostics,
"workspace_tags_active_name must be partial WHERE deleted = 0".into(),
);
}
}
collect_index_diagnostics(
connection,
"typed_ticket_targets",
@@ -449,6 +579,14 @@ pub fn verify_sqlite_ticket_schema(connection: &Connection) -> Result<()> {
}
for table in OWNED_TABLES {
if pre_classification
&& matches!(
*table,
"workspace_tags" | "typed_ticket_tags" | "workspace_tag_operations"
)
{
continue;
}
collect_foreign_key_check_diagnostics(connection, table, &mut diagnostics);
}
@@ -474,6 +612,14 @@ fn create_latest_ticket_schema(connection: &Connection) -> Result<()> {
.map_err(sqlite_err)
}
fn migrate_v7_to_v8(connection: &Connection) -> Result<()> {
// Use the exact canonical DDL rather than duplicating migration definitions.
let (_, tag_schema) = include_str!("latest_schema.sql")
.split_once("-- Workspace tag foundation (v8): shared by fresh schema and v7 upgrade.")
.expect("canonical tag schema marker");
connection.execute_batch(tag_schema).map_err(sqlite_err)
}
fn migrate_v6_to_v7(connection: &Connection) -> Result<()> {
connection
.execute_batch(
@@ -1029,7 +1175,10 @@ mod tests {
create_latest_ticket_schema(&connection).unwrap();
connection
.execute_batch(
"DROP TABLE typed_ticket_targets;
"DROP TABLE typed_ticket_tags;
DROP TABLE workspace_tag_operations;
DROP TABLE workspace_tags;
DROP TABLE typed_ticket_targets;
ALTER TABLE typed_tickets ADD COLUMN repository_id TEXT;
ALTER TABLE typed_tickets ADD COLUMN ref_selector TEXT;
CREATE TABLE ticket_schema_migrations (
@@ -1137,10 +1286,137 @@ mod tests {
assert!(!migrated_attributes.contains_key("ref_selector"));
assert_eq!(
load_applied_migrations(&connection).unwrap(),
BTreeMap::from([(7, BASELINE_MIGRATION_NAME.to_owned())])
BTreeMap::from([(8, BASELINE_MIGRATION_NAME.to_owned())])
);
}
#[test]
fn migrates_v7_to_identical_fresh_schema_without_touching_legacy_labels() {
let upgraded = Connection::open_in_memory().unwrap();
let legacy_sql = include_str!("latest_schema.sql")
.split_once("-- Workspace tag foundation (v8): shared by fresh schema and v7 upgrade.")
.unwrap()
.0;
upgraded.execute_batch(legacy_sql).unwrap();
upgraded.execute_batch(
"CREATE TABLE ticket_schema_migrations (version INTEGER PRIMARY KEY, name TEXT NOT NULL, applied_at TEXT NOT NULL);
INSERT INTO ticket_schema_migrations VALUES (7, 'ticket schema baseline', 'old');
INSERT INTO typed_tickets (workspace_id,ticket_id,slug,title,status,kind,priority,body,workflow_state,workflow_state_explicit)
VALUES ('ws','ticket','ticket','Title','open','task','P2','body','ready',1);
INSERT INTO typed_ticket_labels VALUES ('ws','ticket',0,' Legacy Label ');"
).unwrap();
migrate_sqlite_ticket_schema(&upgraded).unwrap();
verify_sqlite_ticket_schema(&upgraded).unwrap();
let fresh = Connection::open_in_memory().unwrap();
migrate_sqlite_ticket_schema(&fresh).unwrap();
let schema = |conn: &Connection| {
let mut statement = conn.prepare("SELECT type,name,tbl_name,sql FROM sqlite_master WHERE name NOT LIKE 'sqlite_%' ORDER BY type,name").unwrap();
statement
.query_map([], |row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, String>(2)?,
row.get::<_, Option<String>>(3)?
.map(|sql| sql.split_whitespace().collect::<String>()),
))
})
.unwrap()
.collect::<std::result::Result<Vec<_>, _>>()
.unwrap()
};
assert_eq!(schema(&upgraded), schema(&fresh));
let label: String = upgraded
.query_row("SELECT label FROM typed_ticket_labels", [], |row| {
row.get(0)
})
.unwrap();
assert_eq!(label, " Legacy Label ");
let tags: i64 = upgraded
.query_row("SELECT COUNT(*) FROM workspace_tags", [], |row| row.get(0))
.unwrap();
assert_eq!(tags, 0); // Legacy labels are never promoted to catalog tags.
migrate_sqlite_ticket_schema(&upgraded).unwrap();
assert_eq!(schema(&upgraded), schema(&fresh));
}
#[test]
fn tag_schema_verification_detects_drift_without_repair() {
for (drift, expected) in [
("DROP TABLE typed_ticket_tags", "typed_ticket_tags"),
(
"ALTER TABLE workspace_tags RENAME COLUMN last_operation_key TO wrong_observed_key",
"last_operation_key",
),
(
"ALTER TABLE workspace_tag_operations DROP COLUMN result_json",
"result_json",
),
(
"DROP INDEX typed_ticket_tags_workspace_tag",
"typed_ticket_tags_workspace_tag",
),
(
"DROP INDEX workspace_tags_active_name; CREATE UNIQUE INDEX workspace_tags_active_name ON workspace_tags(workspace_id, normalized_name)",
"partial WHERE deleted = 0",
),
(
"DROP TABLE typed_ticket_tags; CREATE TABLE typed_ticket_tags (workspace_id TEXT NOT NULL,ticket_id TEXT NOT NULL,tag_id TEXT NOT NULL, PRIMARY KEY(workspace_id,ticket_id,tag_id)); CREATE INDEX typed_ticket_tags_workspace_tag ON typed_ticket_tags(workspace_id,tag_id,ticket_id)",
"missing foreign key",
),
] {
let connection = Connection::open_in_memory().unwrap();
migrate_sqlite_ticket_schema(&connection).unwrap();
connection.execute_batch(drift).unwrap();
let error = verify_sqlite_ticket_schema(&connection).unwrap_err();
assert!(
error.to_string().contains(expected),
"after {drift}: {error}"
);
assert!(migrate_sqlite_ticket_schema(&connection).is_err());
}
}
#[test]
fn tag_schema_rejects_cross_workspace_links_and_preserves_tombstones() {
let connection = Connection::open_in_memory().unwrap();
connection
.pragma_update(None, "foreign_keys", "ON")
.unwrap();
migrate_sqlite_ticket_schema(&connection).unwrap();
connection.execute_batch(
"INSERT INTO typed_tickets (workspace_id,ticket_id,slug,title,status,kind,priority,body,workflow_state,workflow_state_explicit)
VALUES ('one','ticket','ticket','Title','open','task','P2','body','ready',1);
INSERT INTO workspace_tags VALUES ('two','tag','Name','name','create',0);"
).unwrap();
assert!(
connection
.execute(
"INSERT INTO typed_ticket_tags VALUES ('one','ticket','tag')",
[]
)
.is_err()
);
connection
.execute(
"INSERT INTO workspace_tags VALUES ('one','tag','Name','name','create',0)",
[],
)
.unwrap();
connection
.execute(
"INSERT INTO typed_ticket_tags VALUES ('one','ticket','tag')",
[],
)
.unwrap();
assert!(
connection
.execute("DELETE FROM workspace_tags WHERE workspace_id='one'", [])
.is_err()
);
verify_sqlite_ticket_schema(&connection).unwrap();
}
#[test]
fn rejects_unknown_future_migration_history_without_changing_schema() {
let connection = Connection::open_in_memory().unwrap();
@@ -1155,7 +1431,7 @@ mod tests {
let error = migrate_sqlite_ticket_schema(&connection).unwrap_err();
assert!(error.to_string().contains(
"migration history must contain only the canonical version 7 baseline marker"
"migration history must contain only the canonical version 8 baseline marker"
));
assert_eq!(load_applied_migrations(&connection).unwrap().len(), 2);
}
@@ -1177,7 +1453,7 @@ mod tests {
let error = migrate_sqlite_ticket_schema(&connection).unwrap_err();
assert!(error.to_string().contains(
"migration history must contain only the canonical version 7 baseline marker"
"migration history must contain only the canonical version 8 baseline marker"
));
assert!(!table_exists(&connection, "typed_tickets").unwrap());
}
crates/ticket/src/tags.rs
+323
View File
@@ -0,0 +1,323 @@
//! Workspace tag identity, display-name policy, and transactional SQLite authority.
//!
//! Display names use Rust `str::trim` (Unicode whitespace), then Unicode
//! `str::to_lowercase` for active-name uniqueness. No NFC/NFKC normalization or
//! full case folding is performed: canonically equivalent spellings can differ.
//! Any control character in the input is rejected, including trimmed edges.
//! The trimmed display name must be nonempty and at most 128 UTF-8 bytes.
//! IDs are immutable; deleted names may be recreated under a new ID.
use super::*;
#[cfg(test)]
#[path = "tags_tests.rs"]
mod tests;
/// Workspace-scoped immutable identity with a mutable display name.
/// Names are Unicode-whitespace trimmed, limited to 128 UTF-8 bytes, and
/// deduplicated among active tags using Rust Unicode lowercase (not full case
/// folding or NFC/NFKC). Empty names and any input control characters are invalid.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
pub struct WorkspaceTag {
pub workspace_id: String,
pub id: String,
pub name: String,
pub last_operation_key: String,
pub deleted: bool,
}
/// Active tags in ascending ID order, strictly after `after`; default/max 200.
/// Larger limits are clamped to 200; zero returns an empty page.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
pub struct TagListRequest {
pub after: Option<String>,
#[schemars(range(min = 0, max = 200))]
pub limit: Option<usize>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct WorkspaceTagMutation {
pub operation_key: String,
pub action: WorkspaceTagAction,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum WorkspaceTagAction {
Create {
name: String,
},
Rename {
tag_id: String,
expected_last_operation_key: String,
name: String,
},
Delete {
tag_id: String,
expected_last_operation_key: String,
},
}
/// Compare entire active ID set, then replace it atomically. IDs must be unique;
/// input order is immaterial to CAS, but remains significant for exact replay.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct TicketTagSetRequest {
pub expected_tag_ids: Vec<String>,
pub tag_ids: Vec<String>,
pub operation_key: String,
}
fn normalize_name(input: &str) -> Result<(String, String)> {
let name = input.trim();
if name.is_empty() || name.len() > 128 || input.chars().any(char::is_control) {
return Err(TicketError::Conflict("tag name must be nonempty, contain no control characters, and be at most 128 UTF-8 bytes after trimming".into()));
}
Ok((name.to_owned(), name.to_lowercase()))
}
fn sorted_ids(ids: &[String]) -> Result<Vec<String>> {
if ids.len() > 100 || ids.iter().any(|id| id.len() > 128) {
return Err(TicketError::Conflict(
"tag sets require at most 100 IDs of at most 128 bytes".into(),
));
}
let mut sorted = ids.to_vec();
sorted.sort();
if sorted.iter().any(|id| id.trim().is_empty())
|| sorted.windows(2).any(|pair| pair[0] == pair[1])
{
return Err(TicketError::Conflict(
"tag IDs must be nonempty and unique".into(),
));
}
Ok(sorted)
}
fn read_tag(row: &rusqlite::Row<'_>) -> rusqlite::Result<WorkspaceTag> {
Ok(WorkspaceTag {
workspace_id: row.get(0)?,
id: row.get(1)?,
name: row.get(2)?,
last_operation_key: row.get(3)?,
deleted: row.get::<_, i64>(4)? != 0,
})
}
impl SqliteTicketBackend {
pub(crate) fn load_ticket_tags(
&self,
conn: &Connection,
ticket_id: &str,
) -> Result<Vec<WorkspaceTag>> {
let mut statement = conn.prepare("SELECT tag.workspace_id,tag.tag_id,tag.name,tag.last_operation_key,tag.deleted FROM workspace_tags AS tag JOIN typed_ticket_tags AS link ON link.workspace_id=tag.workspace_id AND link.tag_id=tag.tag_id WHERE link.workspace_id=?1 AND link.ticket_id=?2 AND tag.deleted=0 ORDER BY tag.tag_id").map_err(sqlite_err)?;
statement
.query_map(params![self.workspace_id, ticket_id], read_tag)
.map_err(sqlite_err)?
.collect::<std::result::Result<Vec<_>, _>>()
.map_err(sqlite_err)
}
fn load_tag(&self, conn: &Connection, id: &str) -> Result<WorkspaceTag> {
conn.query_row("SELECT workspace_id,tag_id,name,last_operation_key,deleted FROM workspace_tags WHERE workspace_id=?1 AND tag_id=?2", params![self.workspace_id,id], read_tag).optional().map_err(sqlite_err)?.ok_or_else(|| TicketError::NotFound(format!("workspace tag {id}")))
}
fn tag_input(&self, kind: &str, target: &str, request: &impl Serialize) -> Result<String> {
// Bind authenticated identity, not its mutable assignment/role context:
// a receipt is still the same request after the Worker is reassigned.
// The complete original context is retained separately in the audit row.
let identity: BTreeMap<_, _> = self
.event_attributes
.iter()
.filter(|(key, _)| {
matches!(
key.as_str(),
"source_account_id"
| "source_user_id"
| "source_runtime_id"
| "source_worker_id"
)
})
.collect();
serde_json::to_string(&(kind, target, request, identity)).map_err(sqlite_err)
}
fn replay_tag_operation<T: serde::de::DeserializeOwned>(
&self,
conn: &Connection,
key: &str,
input: &str,
) -> Result<Option<T>> {
validate_required_event_value("operation_key", key)?;
let receipt: Option<(String,String)> = conn.query_row("SELECT input_json,result_json FROM workspace_tag_operations WHERE workspace_id=?1 AND operation_key=?2",params![self.workspace_id,key],|row| Ok((row.get(0)?,row.get(1)?))).optional().map_err(sqlite_err)?;
match receipt {
Some((original, result)) if original == input => {
Ok(Some(serde_json::from_str(&result).map_err(sqlite_err)?))
}
Some(_) => Err(TicketError::OperationFingerprintMismatch {
operation_key: key.to_owned(),
}),
None => Ok(None),
}
}
fn record_tag_operation(
&self,
conn: &Connection,
key: &str,
kind: &str,
target: &str,
input: &str,
snapshots: (&impl Serialize, &impl Serialize),
) -> Result<()> {
conn.execute("INSERT INTO workspace_tag_operations (workspace_id,operation_key,kind,target_id,input_json,before_json,result_json,at,source_context_json) VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9)", params![self.workspace_id,key,kind,target,input,serde_json::to_string(snapshots.0).map_err(sqlite_err)?,serde_json::to_string(snapshots.1).map_err(sqlite_err)?,now_utc(),serde_json::to_string(&self.event_attributes).map_err(sqlite_err)?]).map_err(sqlite_err)?;
Ok(())
}
fn audit_ticket_tags(
&self,
conn: &Connection,
ticket_id: &str,
key: &str,
before: &[WorkspaceTag],
after: &[WorkspaceTag],
) -> Result<()> {
self.insert_event(
conn,
ticket_id,
&TicketEvent {
kind: TicketEventKind::TagsChanged,
author: Some(default_author()),
at: Some(now_utc()),
status: None,
from: None,
to: None,
reason: None,
state_field: None,
heading: Some("Tags changed".into()),
body: MarkdownText::new("Ticket tags changed"),
references: Vec::new(),
attributes: BTreeMap::from([
("operation_key".into(), key.to_owned()),
(
"tags_before".into(),
serde_json::to_string(before).map_err(sqlite_err)?,
),
(
"tags_after".into(),
serde_json::to_string(after).map_err(sqlite_err)?,
),
]),
},
)
}
pub(crate) fn list_tags(&self, request: TagListRequest) -> Result<Vec<WorkspaceTag>> {
self.with_read(|conn| {
let mut statement = conn.prepare("SELECT workspace_id,tag_id,name,last_operation_key,deleted FROM workspace_tags WHERE workspace_id=?1 AND deleted=0 AND (?2 IS NULL OR tag_id>?2) ORDER BY tag_id LIMIT ?3").map_err(sqlite_err)?;
statement.query_map(params![self.workspace_id,request.after,request.limit.unwrap_or(200).min(200) as i64],read_tag).map_err(sqlite_err)?.collect::<std::result::Result<Vec<_>,_>>().map_err(sqlite_err)
})
}
pub(crate) fn mutate_tag(&self, request: WorkspaceTagMutation) -> Result<WorkspaceTag> {
self.with_write(|conn| {
let input = self.tag_input("mutate_workspace_tag", "", &request)?;
if let Some(result) = self.replay_tag_operation(conn,&request.operation_key,&input)? { return Ok(result); }
let (before, result, kind) = match &request.action {
WorkspaceTagAction::Create { name } => {
let (name, normalized) = normalize_name(name)?;
self.require_unique_tag_name(conn,&normalized,None)?;
let millis = unix_epoch_millis_now().map_err(|error| TicketError::Conflict(format!("failed to read tag ID timestamp: {error}")))?;
let id = allocate_record_id(millis, |candidate| {
conn.query_row("SELECT 1 FROM workspace_tags WHERE workspace_id=?1 AND tag_id=?2",params![self.workspace_id,candidate],|_| Ok(())).optional().map(|row| row.is_some()).unwrap_or(true)
}).map_err(|error| TicketError::Conflict(error.to_string()))?;
let tag = WorkspaceTag { workspace_id: self.workspace_id.clone(), id, name, last_operation_key: request.operation_key.clone(), deleted: false };
conn.execute("INSERT INTO workspace_tags (workspace_id,tag_id,name,normalized_name,last_operation_key,deleted) VALUES (?1,?2,?3,?4,?5,0)",params![tag.workspace_id,tag.id,tag.name,normalized,tag.last_operation_key]).map_err(sqlite_err)?;
(None,tag,"create")
}
WorkspaceTagAction::Rename { tag_id,expected_last_operation_key,.. } | WorkspaceTagAction::Delete { tag_id,expected_last_operation_key } => {
let previous = self.load_tag(conn,tag_id)?;
if previous.deleted || &previous.last_operation_key != expected_last_operation_key {
return Err(TicketError::Conflict(format!("stale or deleted tag {tag_id}: expected operation {expected_last_operation_key:?}, actual {:?}",previous.last_operation_key)));
}
let mut tag = previous.clone();
tag.last_operation_key = request.operation_key.clone();
let kind = if let WorkspaceTagAction::Rename { name,.. } = &request.action {
let (name,normalized) = normalize_name(name)?;
self.require_unique_tag_name(conn,&normalized,Some(tag_id))?;
tag.name = name;
conn.execute("UPDATE workspace_tags SET name=?3,normalized_name=?4,last_operation_key=?5 WHERE workspace_id=?1 AND tag_id=?2",params![self.workspace_id,tag_id,tag.name,normalized,request.operation_key]).map_err(sqlite_err)?;
"rename"
} else {
// Capture active snapshots before tombstoning; links and audit are
// cleared/written under the same immediate lock as attachments.
let ticket_ids = {
let mut stmt = conn.prepare("SELECT ticket_id FROM typed_ticket_tags WHERE workspace_id=?1 AND tag_id=?2 ORDER BY ticket_id").map_err(sqlite_err)?;
stmt.query_map(params![self.workspace_id,tag_id],|row| row.get::<_,String>(0)).map_err(sqlite_err)?.collect::<std::result::Result<Vec<_>,_>>().map_err(sqlite_err)?
};
for ticket_id in ticket_ids {
let before = self.load_ticket_tags(conn,&ticket_id)?;
let after: Vec<_> = before.iter().filter(|tag| &tag.id != tag_id).cloned().collect();
conn.execute("DELETE FROM typed_ticket_tags WHERE workspace_id=?1 AND ticket_id=?2 AND tag_id=?3",params![self.workspace_id,ticket_id,tag_id]).map_err(sqlite_err)?;
self.audit_ticket_tags(conn,&ticket_id,&request.operation_key,&before,&after)?;
}
tag.deleted = true;
conn.execute("UPDATE workspace_tags SET deleted=1,last_operation_key=?3 WHERE workspace_id=?1 AND tag_id=?2",params![self.workspace_id,tag_id,request.operation_key]).map_err(sqlite_err)?;
"delete"
};
(Some(previous),tag,kind)
}
};
self.record_tag_operation(conn,&request.operation_key,kind,&result.id,&input,(&before,&result))?;
Ok(result)
})
}
fn require_unique_tag_name(
&self,
conn: &Connection,
normalized: &str,
except: Option<&str>,
) -> Result<()> {
let duplicate = conn.query_row("SELECT 1 FROM workspace_tags WHERE workspace_id=?1 AND normalized_name=?2 AND deleted=0 AND (?3 IS NULL OR tag_id<>?3)",params![self.workspace_id,normalized,except],|_| Ok(())).optional().map_err(sqlite_err)?.is_some();
if duplicate {
return Err(TicketError::Conflict(
"active workspace tag name already exists".into(),
));
}
Ok(())
}
pub(crate) fn set_tags(
&self,
id: TicketIdOrSlug,
request: TicketTagSetRequest,
) -> Result<Vec<WorkspaceTag>> {
self.with_write(|conn| {
// Preserve exact selector input, not just its resolved identity.
let input = self.tag_input("set_ticket_tags", "", &(&id,&request))?;
if let Some(result) = self.replay_tag_operation(conn,&request.operation_key,&input)? { return Ok(result); }
let ticket_id = self.resolve_ticket_id(conn,id)?;
self.require_active_source_assignment(conn,&ticket_id)?;
let before = self.load_ticket_tags(conn,&ticket_id)?;
let expected = sorted_ids(&request.expected_tag_ids)?;
let desired = sorted_ids(&request.tag_ids)?;
if before.iter().map(|tag| tag.id.clone()).collect::<Vec<_>>() != expected {
return Err(TicketError::Conflict("stale Ticket tag set".into()));
}
let after = desired.iter().map(|id| {
let tag = self.load_tag(conn,id)?;
if tag.deleted { return Err(TicketError::Conflict(format!("workspace tag {id} is deleted"))); }
Ok(tag)
}).collect::<Result<Vec<_>>>()?;
conn.execute("DELETE FROM typed_ticket_tags WHERE workspace_id=?1 AND ticket_id=?2",params![self.workspace_id,ticket_id]).map_err(sqlite_err)?;
for tag in &after {
conn.execute("INSERT INTO typed_ticket_tags (workspace_id,ticket_id,tag_id) VALUES (?1,?2,?3)",params![self.workspace_id,ticket_id,tag.id]).map_err(sqlite_err)?;
}
if before != after { self.audit_ticket_tags(conn,&ticket_id,&request.operation_key,&before,&after)?; }
self.record_tag_operation(conn,&request.operation_key,"set_ticket_tags",&ticket_id,&input,(&before,&after))?;
Ok(after)
})
}
}
crates/ticket/src/tags_tests.rs
+801
View File
@@ -0,0 +1,801 @@
use super::*;
use tempfile::tempdir;
fn create_tag(backend: &SqliteTicketBackend, key: &str, name: &str) -> WorkspaceTag {
backend
.mutate_workspace_tag(WorkspaceTagMutation {
operation_key: key.into(),
action: WorkspaceTagAction::Create { name: name.into() },
})
.unwrap()
}
fn rename_tag(
backend: &SqliteTicketBackend,
key: &str,
tag: &WorkspaceTag,
name: &str,
) -> WorkspaceTag {
backend
.mutate_workspace_tag(WorkspaceTagMutation {
operation_key: key.into(),
action: WorkspaceTagAction::Rename {
tag_id: tag.id.clone(),
expected_last_operation_key: tag.last_operation_key.clone(),
name: name.into(),
},
})
.unwrap()
}
fn delete_request(key: &str, tag: &WorkspaceTag) -> WorkspaceTagMutation {
WorkspaceTagMutation {
operation_key: key.into(),
action: WorkspaceTagAction::Delete {
tag_id: tag.id.clone(),
expected_last_operation_key: tag.last_operation_key.clone(),
},
}
}
fn set_request(
key: &str,
expected: &[WorkspaceTag],
desired: &[WorkspaceTag],
) -> TicketTagSetRequest {
TicketTagSetRequest {
expected_tag_ids: expected.iter().map(|t| t.id.clone()).collect(),
tag_ids: desired.iter().map(|t| t.id.clone()).collect(),
operation_key: key.into(),
}
}
fn audit_count(backend: &SqliteTicketBackend) -> i64 {
backend
.open_connection()
.unwrap()
.query_row(
"SELECT COUNT(*) FROM workspace_tag_operations WHERE workspace_id=?1",
params![backend.workspace_id],
|row| row.get(0),
)
.unwrap()
}
#[test]
fn tag_names_have_documented_unicode_lowercase_not_casefold_policy() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let tag = create_tag(&backend, "a", "\u{2003}Ä BC\u{2003}");
assert_eq!(tag.name, "Ä BC");
for name in ["ä bc", " Ä BC "] {
assert!(
backend
.mutate_workspace_tag(WorkspaceTagMutation {
operation_key: "duplicate".into(),
action: WorkspaceTagAction::Create { name: name.into() }
})
.is_err()
);
}
for name in [
"",
" \u{2003}",
"bad\nname",
"\tname",
"a\0",
&"é".repeat(65),
] {
assert!(
backend
.mutate_workspace_tag(WorkspaceTagMutation {
operation_key: "invalid".into(),
action: WorkspaceTagAction::Create { name: name.into() }
})
.is_err()
);
}
create_tag(&backend, "boundary", &"é".repeat(64));
create_tag(&backend, "sharp", "ß");
create_tag(&backend, "ss", "SS"); // Lowercase, not full case folding.
create_tag(&backend, "composed", "é");
create_tag(&backend, "decomposed", "e\u{301}"); // No Unicode normalization.
assert_eq!(audit_count(&backend), 6);
}
#[test]
fn tag_rename_delete_cas_and_name_conflicts_leave_no_audit_or_changes() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let a = create_tag(&backend, "a", "A");
let b = create_tag(&backend, "b", "B");
let renamed = rename_tag(&backend, "rename", &a, "New");
assert_eq!(a.id, renamed.id);
for action in [
WorkspaceTagAction::Rename {
tag_id: a.id.clone(),
expected_last_operation_key: "a".into(),
name: "Stale".into(),
},
WorkspaceTagAction::Delete {
tag_id: a.id.clone(),
expected_last_operation_key: "a".into(),
},
WorkspaceTagAction::Rename {
tag_id: renamed.id.clone(),
expected_last_operation_key: "rename".into(),
name: " b ".into(),
},
WorkspaceTagAction::Rename {
tag_id: renamed.id.clone(),
expected_last_operation_key: "rename".into(),
name: "\n".into(),
},
] {
assert!(
backend
.mutate_workspace_tag(WorkspaceTagMutation {
operation_key: "rejected".into(),
action
})
.is_err()
);
}
assert_eq!(audit_count(&backend), 3);
let active = backend
.list_workspace_tags(TagListRequest::default())
.unwrap();
assert!(active.contains(&renamed) && active.contains(&b));
}
#[test]
fn workspace_mutation_exact_replay_returns_stored_snapshot_before_cas() {
let dir = tempdir().unwrap();
let db = dir.path().join("tags.db");
let backend = SqliteTicketBackend::open(&db, "ws")
.unwrap()
.with_event_attributes(BTreeMap::from([(
"source_worker_id".into(),
"actor-a".into(),
)]));
let request = WorkspaceTagMutation {
operation_key: "create".into(),
action: WorkspaceTagAction::Create { name: " A ".into() },
};
let original = backend.mutate_workspace_tag(request.clone()).unwrap();
let renamed = rename_tag(&backend, "rename", &original, "B");
let deletion = delete_request("delete", &renamed);
let tombstone = backend.mutate_workspace_tag(deletion.clone()).unwrap();
assert!(tombstone.deleted);
assert_eq!(
backend.mutate_workspace_tag(request.clone()).unwrap(),
original
);
assert_eq!(
backend.mutate_workspace_tag(deletion.clone()).unwrap(),
tombstone
);
let restarted = SqliteTicketBackend::open_verified(&db, "ws")
.unwrap()
.with_event_attributes(backend.event_attributes.clone());
assert_eq!(
restarted.mutate_workspace_tag(request.clone()).unwrap(),
original
);
let other_actor = restarted.with_event_attributes(BTreeMap::from([(
"source_worker_id".into(),
"actor-b".into(),
)]));
assert!(matches!(
other_actor.mutate_workspace_tag(request),
Err(TicketError::OperationFingerprintMismatch { .. })
));
assert!(matches!(
backend.mutate_workspace_tag(WorkspaceTagMutation {
operation_key: "create".into(),
action: WorkspaceTagAction::Create { name: "A".into() }
}),
Err(TicketError::OperationFingerprintMismatch { .. })
));
assert_eq!(audit_count(&backend), 3);
assert!(
backend
.list_workspace_tags(TagListRequest::default())
.unwrap()
.is_empty()
);
}
#[test]
fn tag_deletion_detaches_every_ticket_keeps_audit_snapshots_and_recreate_new_id() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let tag = create_tag(&backend, "create", "Old name");
let mut ids = Vec::new();
for i in 0..2 {
let id = backend
.create(NewTicket::new(format!("ticket {i}")))
.unwrap()
.id;
backend
.set_ticket_tags(
id.clone().into(),
set_request(&format!("attach-{i}"), &[], std::slice::from_ref(&tag)),
)
.unwrap();
ids.push(id);
}
let renamed = rename_tag(&backend, "rename", &tag, "New name");
backend
.mutate_workspace_tag(delete_request("delete", &renamed))
.unwrap();
let replacement = create_tag(&backend, "recreate", "new NAME");
assert_ne!(replacement.id, tag.id);
for id in ids {
let ticket = backend.show(id.into()).unwrap();
assert!(ticket.tags.is_empty());
let events: Vec<_> = ticket
.events
.iter()
.filter(|e| e.kind == TicketEventKind::TagsChanged)
.collect();
assert_eq!(events.len(), 2);
let first: Vec<WorkspaceTag> =
serde_json::from_str(&events[0].attributes["tags_after"]).unwrap();
assert_eq!(first, vec![tag.clone()]);
let before_delete: Vec<WorkspaceTag> =
serde_json::from_str(&events[1].attributes["tags_before"]).unwrap();
assert_eq!(before_delete, vec![renamed.clone()]);
assert_eq!(events[1].attributes["tags_after"], "[]");
}
let conn = backend.open_connection().unwrap();
let deleted: i64 = conn
.query_row(
"SELECT deleted FROM workspace_tags WHERE workspace_id='ws' AND tag_id=?1",
params![tag.id],
|row| row.get(0),
)
.unwrap();
assert_eq!(deleted, 1);
assert_eq!(audit_count(&backend), 6);
}
#[test]
fn ticket_tag_set_compares_whole_set_validates_ids_and_replays_historical_result() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let a = create_tag(&backend, "a", "A");
let b = create_tag(&backend, "b", "B");
let id = backend.create(NewTicket::new("ticket")).unwrap().id;
let request = set_request("set", &[], &[b.clone(), a.clone()]);
let stored = backend
.set_ticket_tags(id.clone().into(), request.clone())
.unwrap();
assert!(stored.windows(2).all(|pair| pair[0].id < pair[1].id));
for bad in [
set_request("bad", std::slice::from_ref(&a), &[]),
TicketTagSetRequest {
expected_tag_ids: stored.iter().map(|t| t.id.clone()).collect(),
tag_ids: vec![a.id.clone(), a.id.clone()],
operation_key: "bad".into(),
},
TicketTagSetRequest {
expected_tag_ids: stored.iter().map(|t| t.id.clone()).collect(),
tag_ids: vec!["missing".into()],
operation_key: "bad".into(),
},
] {
assert!(backend.set_ticket_tags(id.clone().into(), bad).is_err());
}
assert_eq!(backend.show(id.clone().into()).unwrap().tags, stored);
let renamed = rename_tag(&backend, "rename", &a, "Renamed");
backend
.mutate_workspace_tag(delete_request("delete", &renamed))
.unwrap();
assert_eq!(
backend
.set_ticket_tags(id.clone().into(), request.clone())
.unwrap(),
stored
);
let mut changed = request.clone();
changed.tag_ids.reverse();
assert!(matches!(
backend.set_ticket_tags(id.clone().into(), changed),
Err(TicketError::OperationFingerprintMismatch { .. })
));
let current = backend.show(id.clone().into()).unwrap();
assert_eq!(current.tags, vec![b]);
assert_eq!(
current
.events
.iter()
.filter(|e| e.kind == TicketEventKind::TagsChanged)
.count(),
2
);
let other_actor = backend.clone().with_event_attributes(BTreeMap::from([(
"source_worker_id".into(),
"actor-b".into(),
)]));
assert!(matches!(
other_actor.set_ticket_tags(id.into(), request),
Err(TicketError::OperationFingerprintMismatch { .. })
));
assert_eq!(audit_count(&backend), 5);
}
#[test]
fn tags_and_operation_keys_are_workspace_scoped() {
let dir = tempdir().unwrap();
let db = dir.path().join("tags.db");
let one = SqliteTicketBackend::open(&db, "one").unwrap();
let two = SqliteTicketBackend::open(&db, "two").unwrap();
let a = create_tag(&one, "same-key", "Same name");
let b = create_tag(&two, "same-key", "Same name");
let ticket = two.create(NewTicket::new("ticket")).unwrap().id;
assert!(
two.mutate_workspace_tag(delete_request("delete", &a))
.is_err()
);
assert!(
two.set_ticket_tags(ticket.clone().into(), set_request("attach", &[], &[a]))
.is_err()
);
two.set_ticket_tags(
ticket.into(),
set_request("attach", &[], std::slice::from_ref(&b)),
)
.unwrap();
assert_eq!(
one.list_workspace_tags(TagListRequest::default())
.unwrap()
.len(),
1
);
assert_eq!(
two.list_workspace_tags(TagListRequest::default()).unwrap(),
vec![b]
);
assert_eq!(audit_count(&one), 1);
}
#[test]
fn tags_do_not_change_content_workflow_queue_targets_or_legacy_labels_in_any_state() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let tag = create_tag(&backend, "tag", "Tag");
for (i, state) in [
TicketWorkflowState::Planning,
TicketWorkflowState::Ready,
TicketWorkflowState::Queued,
TicketWorkflowState::InProgress,
TicketWorkflowState::Done,
TicketWorkflowState::Closed,
]
.into_iter()
.enumerate()
{
let mut new = NewTicket::new(format!("ticket {i}"));
new.workflow_state = Some(state);
new.labels = vec!["legacy label".into()];
new.queued_by = Some("user".into());
new.queued_at = Some("yesterday".into());
let id = backend.create(new).unwrap().id;
let before = backend.show(id.clone().into()).unwrap();
backend
.set_ticket_tags(
id.clone().into(),
set_request(&format!("set-{i}"), &[], std::slice::from_ref(&tag)),
)
.unwrap();
let after = backend.show(id.clone().into()).unwrap();
assert_eq!(before.meta, after.meta);
assert_eq!(before.document, after.document);
assert_eq!(before.resolution, after.resolution);
assert_eq!(
ticket_content_digest(&before),
ticket_content_digest(&after)
);
assert_eq!(after.tags, vec![tag.clone()]);
let summary = backend
.list(TicketListQuery::all())
.unwrap()
.into_iter()
.find(|s| s.id == id)
.unwrap();
assert_eq!(summary.tags, after.tags);
let projection = backend.list_workspace_projection(200).unwrap();
assert_eq!(
projection
.items
.iter()
.find(|s| s.summary.id == id)
.unwrap()
.summary
.tags,
after.tags
);
let page = backend
.list_workspace_projection_page(SqliteTicketListPageQuery {
limit: 200,
..Default::default()
})
.unwrap();
assert_eq!(
page.items
.iter()
.find(|s| s.summary.id == id)
.unwrap()
.summary
.tags,
after.tags
);
}
}
#[test]
fn tag_list_has_bounded_id_keyset_order_and_excludes_deleted() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
// Fixture insertion avoids spending this query test on 205 mutation transactions.
backend
.with_write(|conn| {
for i in 0..205 {
conn.execute(
"INSERT INTO workspace_tags VALUES ('ws',?1,?1,?1,'fixture',0)",
params![format!("tag-{i:03}")],
)
.map_err(sqlite_err)?;
}
Ok(())
})
.unwrap();
let first = backend
.list_workspace_tags(TagListRequest {
after: None,
limit: Some(usize::MAX),
})
.unwrap();
assert_eq!(first.len(), 200);
assert_eq!(first[0].id, "tag-000");
assert_eq!(first[199].id, "tag-199");
assert_eq!(
backend
.list_workspace_tags(TagListRequest::default())
.unwrap(),
first
);
backend
.mutate_workspace_tag(delete_request("delete", &first[0]))
.unwrap();
let tail = backend
.list_workspace_tags(TagListRequest {
after: Some("tag-199".into()),
limit: Some(200),
})
.unwrap();
assert_eq!(tail.len(), 5);
assert!(
backend
.list_workspace_tags(TagListRequest {
after: None,
limit: Some(0)
})
.unwrap()
.is_empty()
);
assert!(
backend
.list_workspace_tags(TagListRequest {
after: None,
limit: Some(1)
})
.unwrap()
.iter()
.all(|t| t.id == "tag-001")
);
}
#[test]
fn failed_tag_mutation_hook_rolls_back_links_tombstone_audit_and_receipt() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let tag = create_tag(&backend, "create", "Tag");
let id = backend.create(NewTicket::new("ticket")).unwrap().id;
let failing = backend.clone().with_mutation_hook(Arc::new(|_, _| {
Err(TicketError::Conflict("test hook".into()))
}));
let attach = set_request("attach", &[], std::slice::from_ref(&tag));
assert!(
failing
.set_ticket_tags(id.clone().into(), attach.clone())
.is_err()
);
assert!(backend.show(id.clone().into()).unwrap().tags.is_empty());
assert_eq!(audit_count(&backend), 1);
backend.set_ticket_tags(id.clone().into(), attach).unwrap();
let before = backend.show(id.clone().into()).unwrap();
let deletion = delete_request("delete", &tag);
assert!(failing.mutate_workspace_tag(deletion.clone()).is_err());
assert_eq!(backend.show(id.into()).unwrap(), before);
assert_eq!(
backend
.list_workspace_tags(TagListRequest::default())
.unwrap(),
vec![tag]
);
assert_eq!(audit_count(&backend), 2);
backend.mutate_workspace_tag(deletion).unwrap();
assert_eq!(audit_count(&backend), 3);
}
#[test]
fn concurrent_tag_replay_and_delete_attach_are_serialized() {
use std::sync::Barrier;
use std::thread;
let dir = tempdir().unwrap();
let db = dir.path().join("tags.db");
let backend = SqliteTicketBackend::open(&db, "ws").unwrap();
let barrier = Arc::new(Barrier::new(3));
let mut joins = Vec::new();
for _ in 0..2 {
let backend = backend.clone();
let barrier = barrier.clone();
joins.push(thread::spawn(move || {
barrier.wait();
create_tag(&backend, "create", "Tag")
}));
}
barrier.wait();
let tag = joins.remove(0).join().unwrap();
assert_eq!(joins.remove(0).join().unwrap(), tag);
assert_eq!(audit_count(&backend), 1);
let id = backend.create(NewTicket::new("ticket")).unwrap().id;
let barrier = Arc::new(Barrier::new(3));
let attach = {
let backend = backend.clone();
let barrier = barrier.clone();
let tag = tag.clone();
let id = id.clone();
thread::spawn(move || {
barrier.wait();
backend.set_ticket_tags(id.into(), set_request("attach", &[], &[tag]))
})
};
let delete = {
let backend = backend.clone();
let barrier = barrier.clone();
let tag = tag.clone();
thread::spawn(move || {
barrier.wait();
backend.mutate_workspace_tag(delete_request("delete", &tag))
})
};
barrier.wait();
let attached = attach.join().unwrap();
assert!(delete.join().unwrap().unwrap().deleted);
assert!(backend.show(id.into()).unwrap().tags.is_empty());
assert!(
backend
.list_workspace_tags(TagListRequest::default())
.unwrap()
.is_empty()
);
assert_eq!(audit_count(&backend), if attached.is_ok() { 3 } else { 2 });
let links: i64 = backend
.open_connection()
.unwrap()
.query_row("SELECT COUNT(*) FROM typed_ticket_tags", [], |row| {
row.get(0)
})
.unwrap();
assert_eq!(links, 0);
}
#[test]
fn ticket_tag_receipts_bind_selector_and_operation_kind_and_replay_before_assignment_fence() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let tag = create_tag(&backend, "create", "Tag");
let id = backend.create(NewTicket::new("ticket")).unwrap().id;
let request = set_request("attach", &[], std::slice::from_ref(&tag));
let mut reused = request.clone();
reused.operation_key = "create".into();
assert!(matches!(
backend.set_ticket_tags(id.clone().into(), reused),
Err(TicketError::OperationFingerprintMismatch { .. })
));
let conn = backend.open_connection().unwrap();
conn.execute_batch("CREATE TABLE ticket_active_worker_assignments (workspace_id TEXT,ticket_id TEXT,runtime_id TEXT,worker_id TEXT,assignment_id TEXT);").unwrap();
conn.execute("INSERT INTO ticket_active_worker_assignments VALUES ('ws',?1,'runtime','worker','assignment')",params![id]).unwrap();
let worker = backend.clone().with_event_attributes(BTreeMap::from([
("source_actor_role".into(), "ticket_worker".into()),
("source_runtime_id".into(), "runtime".into()),
("source_worker_id".into(), "worker".into()),
("source_assignment_id".into(), "assignment".into()),
]));
let stored = worker
.set_ticket_tags(TicketIdOrSlug::Id(id.clone()), request.clone())
.unwrap();
conn.execute("DELETE FROM ticket_active_worker_assignments", [])
.unwrap();
assert_eq!(
worker
.set_ticket_tags(TicketIdOrSlug::Id(id.clone()), request.clone())
.unwrap(),
stored
);
assert!(matches!(
worker.set_ticket_tags(TicketIdOrSlug::Query(id.clone()), request),
Err(TicketError::OperationFingerprintMismatch { .. })
));
assert!(
worker
.set_ticket_tags(
id.clone().into(),
set_request("new-operation", &stored, &[])
)
.is_err()
);
assert_eq!(backend.show(id.clone().into()).unwrap().tags, stored);
backend
.mutate_workspace_tag(delete_request("delete", &tag))
.unwrap();
assert!(
backend
.set_ticket_tags(
id.into(),
set_request("deleted-attach", &[], std::slice::from_ref(&tag))
)
.is_err()
);
assert_eq!(audit_count(&backend), 3);
}
#[test]
fn tag_domain_dispatch_and_wire_contracts_are_exact() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let request = WorkspaceTagMutation {
operation_key: "create".into(),
action: WorkspaceTagAction::Create {
name: "Name".into(),
},
};
assert_eq!(
serde_json::to_value(&request).unwrap(),
serde_json::json!({"operation_key":"create","action":{"kind":"create","name":"Name"}})
);
let operation = TicketBackendOperation::MutateWorkspaceTag { request };
let operation = serde_json::from_value(serde_json::to_value(operation).unwrap()).unwrap();
let TicketBackendOperationResult::WorkspaceTag(tag) =
execute_ticket_backend_operation(&backend, operation).unwrap()
else {
panic!("tag result")
};
let id = backend.create(NewTicket::new("ticket")).unwrap().id;
let result = execute_ticket_backend_operation(
&backend,
TicketBackendOperation::SetTicketTags {
id: id.clone().into(),
request: set_request("set", &[], std::slice::from_ref(&tag)),
},
)
.unwrap();
assert!(
matches!(result,TicketBackendOperationResult::WorkspaceTags(tags) if tags==vec![tag.clone()])
);
let result = execute_ticket_backend_operation(
&backend,
TicketBackendOperation::ListWorkspaceTags {
request: TagListRequest::default(),
},
)
.unwrap();
assert!(matches!(result,TicketBackendOperationResult::WorkspaceTags(tags) if tags==vec![tag]));
let ticket = backend.show(id.into()).unwrap();
let mut wire = serde_json::to_value(&ticket).unwrap();
wire.as_object_mut().unwrap().remove("tags");
assert!(
serde_json::from_value::<Ticket>(wire)
.unwrap()
.tags
.is_empty()
);
let summary = backend.list(TicketListQuery::all()).unwrap().remove(0);
let mut wire = serde_json::to_value(summary).unwrap();
wire.as_object_mut().unwrap().remove("tags");
assert!(
serde_json::from_value::<TicketSummary>(wire)
.unwrap()
.tags
.is_empty()
);
let schema = schemars::schema_for!(WorkspaceTagAction);
assert!(
serde_json::to_string(&schema)
.unwrap()
.contains("expected_last_operation_key")
);
}
#[test]
fn unchanged_tag_set_records_receipt_without_claiming_a_membership_change() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let id = backend.create(NewTicket::new("ticket")).unwrap().id;
let before = backend.show(id.clone().into()).unwrap();
let request = set_request("noop", &[], &[]);
assert!(
backend
.set_ticket_tags(id.clone().into(), request.clone())
.unwrap()
.is_empty()
);
assert!(
backend
.set_ticket_tags(id.clone().into(), request)
.unwrap()
.is_empty()
);
assert_eq!(
backend.show(id.clone().into()).unwrap().events,
before.events
);
assert_eq!(audit_count(&backend), 1);
for request in [
TicketTagSetRequest {
expected_tag_ids: vec!["x".into(); 101],
tag_ids: vec![],
operation_key: "large-observation".into(),
},
TicketTagSetRequest {
expected_tag_ids: vec![],
tag_ids: (0..101).map(|i| format!("tag-{i}")).collect(),
operation_key: "large-desired".into(),
},
TicketTagSetRequest {
expected_tag_ids: vec![],
tag_ids: vec!["x".repeat(129)],
operation_key: "large-id".into(),
},
] {
assert!(backend.set_ticket_tags(id.clone().into(), request).is_err());
assert_eq!(
backend.show(id.clone().into()).unwrap().events,
before.events
);
assert_eq!(audit_count(&backend), 1);
}
}
#[test]
fn tag_receipt_preserves_original_context_but_reassignment_does_not_change_request_identity() {
let dir = tempdir().unwrap();
let backend = SqliteTicketBackend::open(dir.path().join("tags.db"), "ws").unwrap();
let original_context = BTreeMap::from([
("source_runtime_id".into(), "runtime".into()),
("source_worker_id".into(), "worker".into()),
("source_actor_role".into(), "ticket_worker".into()),
("source_assignment_id".into(), "assignment-a".into()),
]);
let original = backend
.clone()
.with_event_attributes(original_context.clone());
let request = WorkspaceTagMutation {
operation_key: "create".into(),
action: WorkspaceTagAction::Create {
name: "ready".into(),
},
};
let tag = original.mutate_workspace_tag(request.clone()).unwrap();
let reassigned = backend.clone().with_event_attributes(BTreeMap::from([
("source_runtime_id".into(), "runtime".into()),
("source_worker_id".into(), "worker".into()),
("source_actor_role".into(), "contributor".into()),
]));
assert_eq!(reassigned.mutate_workspace_tag(request).unwrap(), tag);
let stored: String = backend.with_read(|conn| conn.query_row("SELECT source_context_json FROM workspace_tag_operations WHERE workspace_id='ws' AND operation_key='create'", [], |row| row.get(0)).map_err(sqlite_err)).unwrap();
assert_eq!(
serde_json::from_str::<BTreeMap<String, String>>(&stored).unwrap(),
original_context
);
assert_eq!(audit_count(&backend), 1);
}
crates/ticket/src/tool.rs
+22
View File
@@ -249,6 +249,28 @@ impl From<crate::SqliteTicketBackend> for TicketToolBackend {
}
impl TicketBackend for TicketToolBackend {
fn list_workspace_tags(
&self,
request: crate::TagListRequest,
) -> TicketResult<Vec<crate::WorkspaceTag>> {
self.backend.list_workspace_tags(request)
}
fn mutate_workspace_tag(
&self,
request: crate::WorkspaceTagMutation,
) -> TicketResult<crate::WorkspaceTag> {
self.backend.mutate_workspace_tag(request)
}
fn set_ticket_tags(
&self,
id: TicketIdOrSlug,
request: crate::TicketTagSetRequest,
) -> TicketResult<Vec<crate::WorkspaceTag>> {
self.backend.set_ticket_tags(id, request)
}
fn default_intake_ready_state_change_body(&self, from: &str) -> String {
self.backend.default_intake_ready_state_change_body(from)
}