Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

feat(initiative): add PgInitiativeRepo and sqlx tests (#6449)

Will Hutchinson487d23a0c2a4
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.json
index 6a1bb61af1..9ccfd7516e 100644
--- a/.github/workspace-dep-closures.json
+++ b/.github/workspace-dep-closures.json
@@ -5055,6 +5055,7 @@
"crates/database_env_vars",
"crates/document_sub_type",
"crates/entity_access",
+ "crates/entity_access_db_utils",
"crates/genai_telemetry",
"crates/harness_id",
"crates/harness_token",
@@ -5070,6 +5071,7 @@
"crates/model-entity",
"crates/model-error-response",
"crates/model_file_type",
+ "crates/model_owner",
"crates/model_user",
"crates/models_bulk_upload",
"crates/models_entity_access_management",
@@ -5078,6 +5080,7 @@
"crates/non_empty",
"crates/prompt",
"crates/remote_env_var",
+ "crates/share_permission_db_utils",
"crates/workspace-hack"
],
"invite_email": [
diff --git a/.sqlx/query-030b0d08f8d634e36e79c2fc35c4a4bb3260f6e35d01420cd2ae8546ed5d97f2.json b/.sqlx/query-030b0d08f8d634e36e79c2fc35c4a4bb3260f6e35d01420cd2ae8546ed5d97f2.json
new file mode 100644
index 0000000000..51915bc811
--- /dev/null
+++ b/.sqlx/query-030b0d08f8d634e36e79c2fc35c4a4bb3260f6e35d01420cd2ae8546ed5d97f2.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM initiative_member\n WHERE initiative_id = $1 AND user_id = ANY($2)\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "030b0d08f8d634e36e79c2fc35c4a4bb3260f6e35d01420cd2ae8546ed5d97f2"
+}
diff --git a/.sqlx/query-05afed4baa89c7e57afc95aaaba1e63b2cb637ac8a3d66734e0259b2314417c9.json b/.sqlx/query-05afed4baa89c7e57afc95aaaba1e63b2cb637ac8a3d66734e0259b2314417c9.json
new file mode 100644
index 0000000000..0a29e43d72
--- /dev/null
+++ b/.sqlx/query-05afed4baa89c7e57afc95aaaba1e63b2cb637ac8a3d66734e0259b2314417c9.json
@@ -0,0 +1,118 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT\n i.id,\n i.name,\n i.description,\n i.owner_user_id,\n i.created_at,\n i.updated_at,\n i.share_permission_id,\n COALESCE(\n array_agg(DISTINCT m.user_id) FILTER (WHERE m.user_id IS NOT NULL),\n '{}'::text[]\n ) AS \"member_ids!\",\n COALESCE(\n array_agg(DISTINCT t.task_id) FILTER (WHERE t.task_id IS NOT NULL),\n '{}'::text[]\n ) AS \"task_ids!\",\n sp.\"linkShare\" AS \"link_share?\",\n sp.\"linkShareAccessLevel\" AS \"link_share_access_level?: AccessLevel\",\n sp.team_share_access_level AS \"team_share_access_level?: AccessLevel\",\n COALESCE(\n (\n SELECT json_agg(json_build_object(\n 'channel_id', channel.\"channel_id\",\n 'access_level', channel.\"access_level\"\n ))\n FROM \"ChannelSharePermission\" channel\n WHERE channel.\"share_permission_id\" = i.share_permission_id\n ),\n '[]'::json\n ) AS \"channel_share_permissions!\"\n FROM initiative i\n JOIN \"SharePermission\" sp ON sp.id = i.share_permission_id\n LEFT JOIN initiative_member m ON m.initiative_id = i.id\n LEFT JOIN task_initiative t ON t.initiative_id = i.id\n WHERE i.id = $1\n GROUP BY\n i.id,\n i.name,\n i.description,\n i.owner_user_id,\n i.created_at,\n i.updated_at,\n i.share_permission_id,\n sp.\"linkShare\",\n sp.\"linkShareAccessLevel\",\n sp.team_share_access_level\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Uuid"
+ },
+ {
+ "ordinal": 1,
+ "name": "name",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 2,
+ "name": "description",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 3,
+ "name": "owner_user_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 4,
+ "name": "created_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 5,
+ "name": "updated_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 6,
+ "name": "share_permission_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 7,
+ "name": "member_ids!",
+ "type_info": "TextArray"
+ },
+ {
+ "ordinal": 8,
+ "name": "task_ids!",
+ "type_info": "TextArray"
+ },
+ {
+ "ordinal": 9,
+ "name": "link_share?",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 10,
+ "name": "link_share_access_level?: AccessLevel",
+ "type_info": {
+ "Custom": {
+ "name": "\"AccessLevel\"",
+ "kind": {
+ "Enum": [
+ "view",
+ "comment",
+ "edit",
+ "owner"
+ ]
+ }
+ }
+ }
+ },
+ {
+ "ordinal": 11,
+ "name": "team_share_access_level?: AccessLevel",
+ "type_info": {
+ "Custom": {
+ "name": "\"AccessLevel\"",
+ "kind": {
+ "Enum": [
+ "view",
+ "comment",
+ "edit",
+ "owner"
+ ]
+ }
+ }
+ }
+ },
+ {
+ "ordinal": 12,
+ "name": "channel_share_permissions!",
+ "type_info": "Json"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false,
+ false,
+ false,
+ false,
+ false,
+ null,
+ null,
+ true,
+ true,
+ true,
+ null
+ ]
+ },
+ "hash": "05afed4baa89c7e57afc95aaaba1e63b2cb637ac8a3d66734e0259b2314417c9"
+}
diff --git a/.sqlx/query-2fac2ac9ac6e19757b822ce7b8a34d0e0beb7e3cb0db7087d3835c51788e81a8.json b/.sqlx/query-2fac2ac9ac6e19757b822ce7b8a34d0e0beb7e3cb0db7087d3835c51788e81a8.json
new file mode 100644
index 0000000000..0ab6cbee3b
--- /dev/null
+++ b/.sqlx/query-2fac2ac9ac6e19757b822ce7b8a34d0e0beb7e3cb0db7087d3835c51788e81a8.json
@@ -0,0 +1,18 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n UPDATE initiative\n SET\n name = CASE WHEN $2 THEN $3 ELSE name END,\n description = CASE WHEN $4 THEN $5 ELSE description END,\n updated_at = now()\n WHERE id = $1\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Bool",
+ "Text",
+ "Bool",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "2fac2ac9ac6e19757b822ce7b8a34d0e0beb7e3cb0db7087d3835c51788e81a8"
+}
diff --git a/.sqlx/query-34b287ee871701effe4febb7c5a0b336390afdd9b7421169ec40298cfc02312a.json b/.sqlx/query-34b287ee871701effe4febb7c5a0b336390afdd9b7421169ec40298cfc02312a.json
new file mode 100644
index 0000000000..c37800ab6a
--- /dev/null
+++ b/.sqlx/query-34b287ee871701effe4febb7c5a0b336390afdd9b7421169ec40298cfc02312a.json
@@ -0,0 +1,40 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n WITH user_source_ids AS (\n SELECT cp.channel_id::text AS source_id\n FROM comms_channel_participants cp\n WHERE cp.user_id = $1 AND cp.left_at IS NULL\n UNION ALL\n SELECT t.team_id::text\n FROM team_user t\n WHERE t.user_id = $1\n UNION ALL\n SELECT $1\n )\n SELECT\n i.id,\n i.name,\n i.description,\n i.updated_at\n FROM initiative i\n JOIN \"SharePermission\" sp ON sp.id = i.share_permission_id\n WHERE EXISTS (\n SELECT 1\n FROM entity_access ea\n WHERE ea.entity_id = i.id\n AND ea.entity_type = 'initiative'\n AND ea.source_id IN (SELECT source_id FROM user_source_ids)\n )\n OR (\n sp.\"linkShare\" = 'TEAM'\n AND EXISTS (\n SELECT 1\n FROM team_user owner_tu\n WHERE owner_tu.user_id = i.owner_user_id\n AND owner_tu.team_id::text IN (SELECT source_id FROM user_source_ids)\n )\n )\n ORDER BY i.updated_at DESC\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Uuid"
+ },
+ {
+ "ordinal": 1,
+ "name": "name",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 2,
+ "name": "description",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 3,
+ "name": "updated_at",
+ "type_info": "Timestamptz"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false,
+ false
+ ]
+ },
+ "hash": "34b287ee871701effe4febb7c5a0b336390afdd9b7421169ec40298cfc02312a"
+}
diff --git a/.sqlx/query-3e6aa73a7666c1f566e2b05d03e87218bf00c372f3709c01fe1ec1ec2060f11d.json b/.sqlx/query-3e6aa73a7666c1f566e2b05d03e87218bf00c372f3709c01fe1ec1ec2060f11d.json
new file mode 100644
index 0000000000..000b975d9b
--- /dev/null
+++ b/.sqlx/query-3e6aa73a7666c1f566e2b05d03e87218bf00c372f3709c01fe1ec1ec2060f11d.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM \"SharePermission\"\n WHERE id = $1\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "3e6aa73a7666c1f566e2b05d03e87218bf00c372f3709c01fe1ec1ec2060f11d"
+}
diff --git a/.sqlx/query-4fd6e422ff633b1d851637e9991401dd8abeaff2a11a3c95f30f427123e3ad68.json b/.sqlx/query-4fd6e422ff633b1d851637e9991401dd8abeaff2a11a3c95f30f427123e3ad68.json
new file mode 100644
index 0000000000..e724baf4dd
--- /dev/null
+++ b/.sqlx/query-4fd6e422ff633b1d851637e9991401dd8abeaff2a11a3c95f30f427123e3ad68.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n UPDATE initiative\n SET updated_at = now()\n WHERE id = $1\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "4fd6e422ff633b1d851637e9991401dd8abeaff2a11a3c95f30f427123e3ad68"
+}
diff --git a/.sqlx/query-6d8b8d883a247884c6381d885097e1e7909e92951140190de71780fbf10f4ae5.json b/.sqlx/query-6d8b8d883a247884c6381d885097e1e7909e92951140190de71780fbf10f4ae5.json
new file mode 100644
index 0000000000..14755c78d6
--- /dev/null
+++ b/.sqlx/query-6d8b8d883a247884c6381d885097e1e7909e92951140190de71780fbf10f4ae5.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT id\n FROM initiative\n WHERE id = $1\n FOR UPDATE\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Uuid"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "6d8b8d883a247884c6381d885097e1e7909e92951140190de71780fbf10f4ae5"
+}
diff --git a/.sqlx/query-6f52c851c58a41329818e4e76fc97bd706fbcc930eca682cb45653d96ef30cca.json b/.sqlx/query-6f52c851c58a41329818e4e76fc97bd706fbcc930eca682cb45653d96ef30cca.json
new file mode 100644
index 0000000000..23f6bbbe12
--- /dev/null
+++ b/.sqlx/query-6f52c851c58a41329818e4e76fc97bd706fbcc930eca682cb45653d96ef30cca.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO initiative_member (initiative_id, user_id)\n SELECT $1, UNNEST($2::text[])\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "6f52c851c58a41329818e4e76fc97bd706fbcc930eca682cb45653d96ef30cca"
+}
diff --git a/.sqlx/query-7196b28f3cd2bc4bd389c7e2e0ddfd2463489ce3685a0dbe38e291c0e4b81e8a.json b/.sqlx/query-7196b28f3cd2bc4bd389c7e2e0ddfd2463489ce3685a0dbe38e291c0e4b81e8a.json
new file mode 100644
index 0000000000..a59eaa5427
--- /dev/null
+++ b/.sqlx/query-7196b28f3cd2bc4bd389c7e2e0ddfd2463489ce3685a0dbe38e291c0e4b81e8a.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO initiative_member (initiative_id, user_id)\n SELECT $1, UNNEST($2::text[])\n ON CONFLICT DO NOTHING\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "7196b28f3cd2bc4bd389c7e2e0ddfd2463489ce3685a0dbe38e291c0e4b81e8a"
+}
diff --git a/.sqlx/query-78f336260899ad227833043c7d8934509d722f58e00963c895cde7def825233d.json b/.sqlx/query-78f336260899ad227833043c7d8934509d722f58e00963c895cde7def825233d.json
new file mode 100644
index 0000000000..07a802e25a
--- /dev/null
+++ b/.sqlx/query-78f336260899ad227833043c7d8934509d722f58e00963c895cde7def825233d.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM initiative\n WHERE id = $1\n RETURNING share_permission_id\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "share_permission_id",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "78f336260899ad227833043c7d8934509d722f58e00963c895cde7def825233d"
+}
diff --git a/.sqlx/query-7c2b158ff8819b7717f5373a1cd8dddf1463122d30c610c20505778989d5b219.json b/.sqlx/query-7c2b158ff8819b7717f5373a1cd8dddf1463122d30c610c20505778989d5b219.json
new file mode 100644
index 0000000000..45fc128c99
--- /dev/null
+++ b/.sqlx/query-7c2b158ff8819b7717f5373a1cd8dddf1463122d30c610c20505778989d5b219.json
@@ -0,0 +1,23 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO task_initiative (task_id, initiative_id)\n SELECT dst.document_id, $1\n FROM UNNEST($2::text[]) AS t(task_id)\n JOIN document_sub_type dst\n ON dst.document_id = t.task_id AND dst.sub_type = 'task'\n ON CONFLICT (task_id) DO UPDATE\n SET initiative_id = EXCLUDED.initiative_id, created_at = now()\n RETURNING task_id\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "task_id",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "TextArray"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "7c2b158ff8819b7717f5373a1cd8dddf1463122d30c610c20505778989d5b219"
+}
diff --git a/.sqlx/query-825259e5d8de4735f2d7e8f54548fc87b80658ea7ec791a85fd1a4309c02c9c5.json b/.sqlx/query-825259e5d8de4735f2d7e8f54548fc87b80658ea7ec791a85fd1a4309c02c9c5.json
new file mode 100644
index 0000000000..71c41af0d5
--- /dev/null
+++ b/.sqlx/query-825259e5d8de4735f2d7e8f54548fc87b80658ea7ec791a85fd1a4309c02c9c5.json
@@ -0,0 +1,16 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n UPDATE \"ChannelSharePermission\"\n SET access_level = $3::text::\"AccessLevel\"\n WHERE share_permission_id = $1 AND channel_id = $2\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "825259e5d8de4735f2d7e8f54548fc87b80658ea7ec791a85fd1a4309c02c9c5"
+}
diff --git a/.sqlx/query-8273c42a36b8aa48f8c4e841fb093170ea326933f7d83b1cc716111212865591.json b/.sqlx/query-8273c42a36b8aa48f8c4e841fb093170ea326933f7d83b1cc716111212865591.json
new file mode 100644
index 0000000000..e213d54056
--- /dev/null
+++ b/.sqlx/query-8273c42a36b8aa48f8c4e841fb093170ea326933f7d83b1cc716111212865591.json
@@ -0,0 +1,18 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO initiative (\n id,\n name,\n description,\n owner_user_id,\n share_permission_id\n )\n VALUES ($1, $2, $3, $4, $5)\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text",
+ "Text",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "8273c42a36b8aa48f8c4e841fb093170ea326933f7d83b1cc716111212865591"
+}
diff --git a/.sqlx/query-87b606e8880ffd99d09bee637fa4b2942a6734ad3225b9104222cd930969cb8f.json b/.sqlx/query-87b606e8880ffd99d09bee637fa4b2942a6734ad3225b9104222cd930969cb8f.json
new file mode 100644
index 0000000000..5bea1a5384
--- /dev/null
+++ b/.sqlx/query-87b606e8880ffd99d09bee637fa4b2942a6734ad3225b9104222cd930969cb8f.json
@@ -0,0 +1,118 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT\n i.id,\n i.name,\n i.description,\n i.owner_user_id,\n i.created_at,\n i.updated_at,\n i.share_permission_id,\n COALESCE(\n array_agg(DISTINCT m.user_id) FILTER (WHERE m.user_id IS NOT NULL),\n '{}'::text[]\n ) AS \"member_ids!\",\n COALESCE(\n array_agg(DISTINCT t.task_id) FILTER (WHERE t.task_id IS NOT NULL),\n '{}'::text[]\n ) AS \"task_ids!\",\n sp.\"linkShare\" AS \"link_share?\",\n sp.\"linkShareAccessLevel\" AS \"link_share_access_level?: AccessLevel\",\n sp.team_share_access_level AS \"team_share_access_level?: AccessLevel\",\n COALESCE(\n json_agg(json_build_object(\n 'channel_id', channel.\"channel_id\",\n 'access_level', channel.\"access_level\"\n )) FILTER (WHERE channel.\"channel_id\" IS NOT NULL),\n '[]'\n ) AS \"channel_share_permissions?\"\n FROM initiative i\n JOIN \"SharePermission\" sp ON sp.id = i.share_permission_id\n LEFT JOIN initiative_member m ON m.initiative_id = i.id\n LEFT JOIN task_initiative t ON t.initiative_id = i.id\n LEFT JOIN \"ChannelSharePermission\" channel\n ON channel.\"share_permission_id\" = sp.id\n WHERE i.id = $1\n GROUP BY\n i.id,\n i.name,\n i.description,\n i.owner_user_id,\n i.created_at,\n i.updated_at,\n i.share_permission_id,\n sp.\"linkShare\",\n sp.\"linkShareAccessLevel\",\n sp.team_share_access_level\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Uuid"
+ },
+ {
+ "ordinal": 1,
+ "name": "name",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 2,
+ "name": "description",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 3,
+ "name": "owner_user_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 4,
+ "name": "created_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 5,
+ "name": "updated_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 6,
+ "name": "share_permission_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 7,
+ "name": "member_ids!",
+ "type_info": "TextArray"
+ },
+ {
+ "ordinal": 8,
+ "name": "task_ids!",
+ "type_info": "TextArray"
+ },
+ {
+ "ordinal": 9,
+ "name": "link_share?",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 10,
+ "name": "link_share_access_level?: AccessLevel",
+ "type_info": {
+ "Custom": {
+ "name": "\"AccessLevel\"",
+ "kind": {
+ "Enum": [
+ "view",
+ "comment",
+ "edit",
+ "owner"
+ ]
+ }
+ }
+ }
+ },
+ {
+ "ordinal": 11,
+ "name": "team_share_access_level?: AccessLevel",
+ "type_info": {
+ "Custom": {
+ "name": "\"AccessLevel\"",
+ "kind": {
+ "Enum": [
+ "view",
+ "comment",
+ "edit",
+ "owner"
+ ]
+ }
+ }
+ }
+ },
+ {
+ "ordinal": 12,
+ "name": "channel_share_permissions?",
+ "type_info": "Json"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false,
+ false,
+ false,
+ false,
+ false,
+ null,
+ null,
+ true,
+ true,
+ true,
+ null
+ ]
+ },
+ "hash": "87b606e8880ffd99d09bee637fa4b2942a6734ad3225b9104222cd930969cb8f"
+}
diff --git a/.sqlx/query-b1ceaae1abccab9be8102b59a717a14b7f91d29ccf55ec6cbf0ebcc7696224e1.json b/.sqlx/query-b1ceaae1abccab9be8102b59a717a14b7f91d29ccf55ec6cbf0ebcc7696224e1.json
new file mode 100644
index 0000000000..e5f380b760
--- /dev/null
+++ b/.sqlx/query-b1ceaae1abccab9be8102b59a717a14b7f91d29ccf55ec6cbf0ebcc7696224e1.json
@@ -0,0 +1,28 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT task_id, initiative_id\n FROM task_initiative\n WHERE task_id = ANY($1)\n FOR UPDATE\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "task_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "initiative_id",
+ "type_info": "Uuid"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": [
+ false,
+ false
+ ]
+ },
+ "hash": "b1ceaae1abccab9be8102b59a717a14b7f91d29ccf55ec6cbf0ebcc7696224e1"
+}
diff --git a/.sqlx/query-b8dbdf5bd764a1c7e49c5dd033f53fddb8e06cc23840229c3f0219d41095db3d.json b/.sqlx/query-b8dbdf5bd764a1c7e49c5dd033f53fddb8e06cc23840229c3f0219d41095db3d.json
new file mode 100644
index 0000000000..30d0b3719c
--- /dev/null
+++ b/.sqlx/query-b8dbdf5bd764a1c7e49c5dd033f53fddb8e06cc23840229c3f0219d41095db3d.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT share_permission_id\n FROM initiative\n WHERE id = $1\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "share_permission_id",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "b8dbdf5bd764a1c7e49c5dd033f53fddb8e06cc23840229c3f0219d41095db3d"
+}
diff --git a/.sqlx/query-d5eb58c854011331a2fd160bc618f65cb4e0202a434e459c8e1deb3c4ee09a48.json b/.sqlx/query-d5eb58c854011331a2fd160bc618f65cb4e0202a434e459c8e1deb3c4ee09a48.json
new file mode 100644
index 0000000000..fd1b7ca01b
--- /dev/null
+++ b/.sqlx/query-d5eb58c854011331a2fd160bc618f65cb4e0202a434e459c8e1deb3c4ee09a48.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT id\n FROM \"Document\"\n WHERE id = ANY($1)\n ORDER BY id\n FOR UPDATE\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "d5eb58c854011331a2fd160bc618f65cb4e0202a434e459c8e1deb3c4ee09a48"
+}
diff --git a/.sqlx/query-e4f15ad91d99ba713786127ac520e2f4e8fe092d37e7062df1d7b0364a182510.json b/.sqlx/query-e4f15ad91d99ba713786127ac520e2f4e8fe092d37e7062df1d7b0364a182510.json
new file mode 100644
index 0000000000..f9bf51ee5e
--- /dev/null
+++ b/.sqlx/query-e4f15ad91d99ba713786127ac520e2f4e8fe092d37e7062df1d7b0364a182510.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM task_initiative\n WHERE task_id = $1 AND initiative_id = $2\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Uuid"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "e4f15ad91d99ba713786127ac520e2f4e8fe092d37e7062df1d7b0364a182510"
+}
diff --git a/Cargo.lock b/Cargo.lock
index 4f3d71b415..28740ad7cb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8718,17 +8718,23 @@ dependencies = [
name = "initiative"
version = "0.1.0"
dependencies = [
+ "anyhow",
"axum",
"chrono",
"entity_access",
+ "entity_access_db_utils",
"macro_authorization",
+ "macro_db_migrator",
"macro_user_id",
+ "macro_uuid",
"mockall",
+ "model-entity",
"model-error-response",
"models_permissions",
"rootcause",
"serde",
"serde_json",
+ "share_permission_db_utils",
"sqlx",
"thiserror 2.0.18",
"tokio",
diff --git a/crates/initiative/Cargo.toml b/crates/initiative/Cargo.toml
index b634c10aa1..489d569302 100644
--- a/crates/initiative/Cargo.toml
+++ b/crates/initiative/Cargo.toml
@@ -5,7 +5,7 @@ publish = false
version = "0.1.0"
[features]
-default = ["ports"]
+default = ["ports", "postgres"]
inbound = [
"dep:axum",
"dep:macro_authorization",
@@ -16,18 +16,31 @@ inbound = [
]
outbound = ["ports"]
ports = ["dep:entity_access", "dep:tracing"]
-postgres = ["dep:sqlx", "outbound"]
+postgres = [
+ "dep:sqlx",
+ "dep:entity_access_db_utils",
+ "dep:share_permission_db_utils",
+ "dep:model-entity",
+ "dep:macro_uuid",
+ "dep:serde_json",
+ "outbound",
+]
[dependencies]
axum = { workspace = true, optional = true }
chrono = { workspace = true, features = ["serde"] }
entity_access = { path = "../entity_access", optional = true, default-features = false, features = ["ports"] }
+entity_access_db_utils = { path = "../entity_access_db_utils", optional = true }
macro_authorization = { path = "../macro_authorization", optional = true, default-features = false, features = ["axum"] }
macro_user_id = { path = "../macro_user_id" }
+macro_uuid = { path = "../macro_uuid", optional = true }
+model-entity = { path = "../model-entity", optional = true }
model-error-response = { path = "../model-error-response", optional = true }
models_permissions = { path = "../models_permissions" }
rootcause = { workspace = true }
serde = { workspace = true }
+serde_json = { workspace = true, optional = true }
+share_permission_db_utils = { path = "../share_permission_db_utils", optional = true }
sqlx = { workspace = true, optional = true }
thiserror = { workspace = true }
tracing = { workspace = true, optional = true }
@@ -38,5 +51,7 @@ workspace-hack = { version = "0.1", path = "../workspace-hack" }
mockall = { workspace = true }
[dev-dependencies]
+anyhow = { workspace = true }
+macro_db_migrator = { path = "../macro_db_migrator" }
serde_json = { workspace = true }
tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
diff --git a/crates/initiative/src/outbound.rs b/crates/initiative/src/outbound.rs
index 8a1ba5af09..4ca91468d4 100644
--- a/crates/initiative/src/outbound.rs
+++ b/crates/initiative/src/outbound.rs
@@ -1 +1,7 @@
//! Outbound (driven) adapters for initiatives.
+
+#[cfg(feature = "postgres")]
+mod pg_initiative_repo;
+
+#[cfg(feature = "postgres")]
+pub use pg_initiative_repo::PgInitiativeRepo;
diff --git a/crates/initiative/src/outbound/pg_initiative_repo.rs b/crates/initiative/src/outbound/pg_initiative_repo.rs
new file mode 100644
index 0000000000..539106e153
--- /dev/null
+++ b/crates/initiative/src/outbound/pg_initiative_repo.rs
@@ -0,0 +1,373 @@
+//! PostgreSQL implementation of [`InitiativeRepo`].
+
+mod create;
+mod list;
+mod members;
+mod share;
+mod tasks;
+
+#[cfg(test)]
+mod test;
+
+use std::str::FromStr;
+
+use macro_user_id::cowlike::CowLike;
+use macro_user_id::user_id::MacroUserIdStr;
+use model_entity::{Entity, EntityType};
+use models_permissions::share_permission::access_level::AccessLevel;
+use models_permissions::share_permission::channel_share_permission::ChannelSharePermission;
+use models_permissions::share_permission::team_share::{TeamShareCreation, TeamShareFacts};
+use models_permissions::share_permission::{LinkShare, SharePermissionV2, TeamLinkShareDefault};
+use rootcause::prelude::*;
+use share_permission_db_utils::team_share::TeamShareError;
+use sqlx::postgres::PgDatabaseError;
+use sqlx::{Executor, PgPool, Postgres};
+
+use crate::domain::models::{
+ AssignTasksResult, CreateInitiativeRepoArgs, InitiativeBasic, InitiativeDetail,
+ InitiativeError, InitiativeId, InitiativeList, UpdateInitiativeRepoArgs,
+};
+use crate::domain::ports::InitiativeRepo;
+
+const DETAIL_ACCESS_WITHOUT_ACTOR: AccessLevel = AccessLevel::View;
+
+/// PostgreSQL `InitiativeRepo`. One pool. One transaction per mutation.
+#[derive(Clone)]
+pub struct PgInitiativeRepo {
+ pool: PgPool,
+}
+
+impl PgInitiativeRepo {
+ /// Wire at the composition root. Not constructed from inbound or domain.
+ pub fn new(pool: PgPool) -> Self {
+ Self { pool }
+ }
+}
+
+impl InitiativeRepo for PgInitiativeRepo {
+ type Err = InitiativeError;
+
+ #[tracing::instrument(err, skip(self, args, share_permission))]
+ async fn create(
+ &self,
+ args: CreateInitiativeRepoArgs,
+ share_permission: SharePermissionV2,
+ team_share: TeamShareCreation,
+ ) -> Result<InitiativeDetail, Self::Err> {
+ create::create(&self.pool, args, share_permission, team_share).await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_basic(&self, id: InitiativeId) -> Result<Option<InitiativeBasic>, Self::Err> {
+ load_record(&self.pool, id)
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?
+ .map(InitiativeRecord::into_basic)
+ .transpose()
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_detail(&self, id: InitiativeId) -> Result<Option<InitiativeDetail>, Self::Err> {
+ load_record(&self.pool, id)
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?
+ .map(InitiativeRecord::into_detail)
+ .transpose()
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn list_accessible(
+ &self,
+ user_id: &MacroUserIdStr<'static>,
+ ) -> Result<InitiativeList, Self::Err> {
+ list::list_accessible(&self.pool, user_id).await
+ }
+
+ #[tracing::instrument(err, skip(self, args))]
+ async fn update(&self, args: UpdateInitiativeRepoArgs) -> Result<InitiativeDetail, Self::Err> {
+ create::update(&self.pool, args).await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_team_share_facts(&self, id: InitiativeId) -> Result<TeamShareFacts, Self::Err> {
+ share::get_team_share_facts(&self.pool, id).await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_team_default_link_share(
+ &self,
+ user_id: &MacroUserIdStr<'static>,
+ ) -> Result<Option<TeamLinkShareDefault>, Self::Err> {
+ share::get_team_default_link_share(&self.pool, user_id).await
+ }
+
+ #[tracing::instrument(err, skip(self, task_ids))]
+ async fn assign_tasks(
+ &self,
+ id: InitiativeId,
+ task_ids: Vec<String>,
+ ) -> Result<Vec<AssignTasksResult>, Self::Err> {
+ tasks::assign_tasks(&self.pool, id, task_ids).await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn unassign_task(&self, id: InitiativeId, task_id: &str) -> Result<(), Self::Err> {
+ tasks::unassign_task(&self.pool, id, task_id).await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn delete(&self, id: InitiativeId) -> Result<(), Self::Err> {
+ create::delete(&self.pool, id).await
+ }
+}
+
+struct InitiativeRecord {
+ id: uuid::Uuid,
+ name: String,
+ description: String,
+ owner_user_id: String,
+ created_at: chrono::DateTime<chrono::Utc>,
+ updated_at: chrono::DateTime<chrono::Utc>,
+ share_permission_id: String,
+ member_ids: Vec<String>,
+ task_ids: Vec<String>,
+ link_share: Option<String>,
+ link_share_access_level: Option<AccessLevel>,
+ team_share_access_level: Option<AccessLevel>,
+ channel_share_permissions: serde_json::Value,
+}
+
+impl InitiativeRecord {
+ fn into_basic(self) -> Result<InitiativeBasic, InitiativeError> {
+ Ok(InitiativeBasic {
+ id: InitiativeId::from_uuid(self.id),
+ name: self.name,
+ owner_id: parse_owner(&self.owner_user_id)?,
+ })
+ }
+
+ fn into_detail(self) -> Result<InitiativeDetail, InitiativeError> {
+ let share_permission = share_permission_from_record(&self)?;
+ let owner_id = parse_owner(&self.owner_user_id)?;
+ Ok(InitiativeDetail {
+ id: InitiativeId::from_uuid(self.id),
+ name: self.name,
+ description: description_from_db(self.description),
+ owner_id,
+ member_ids: parse_members(self.member_ids)?,
+ task_ids: self.task_ids,
+ share_permission,
+ user_access_level: DETAIL_ACCESS_WITHOUT_ACTOR,
+ created_at: self.created_at,
+ updated_at: self.updated_at,
+ })
+ }
+}
+
+fn description_from_db(value: String) -> Option<String> {
+ let trimmed = value.trim();
+ if trimmed.is_empty() {
+ None
+ } else {
+ Some(trimmed.to_string())
+ }
+}
+
+fn description_to_db(value: Option<&str>) -> &str {
+ value.unwrap_or("")
+}
+
+fn parse_owner(raw: &str) -> Result<MacroUserIdStr<'static>, InitiativeError> {
+ MacroUserIdStr::parse_from_str(raw)
+ .map(|id| id.into_owned())
+ .map_err(|error| map_sqlx(AdapterError::Sqlx(sqlx::Error::Decode(Box::new(error)))))
+}
+
+fn parse_members(raw: Vec<String>) -> Result<Vec<MacroUserIdStr<'static>>, InitiativeError> {
+ raw.into_iter()
+ .filter(|id| !id.is_empty())
+ .map(|id| parse_owner(&id))
+ .collect()
+}
+
+fn share_permission_from_record(
+ record: &InitiativeRecord,
+) -> Result<SharePermissionV2, InitiativeError> {
+ let channel_share_permissions = serde_json::from_value::<Vec<ChannelSharePermission>>(
+ record.channel_share_permissions.clone(),
+ )
+ .map_err(|error| map_sqlx(AdapterError::Sqlx(sqlx::Error::Decode(Box::new(error)))))?;
+ let channel_share_permissions =
+ Some(channel_share_permissions).filter(|permissions| !permissions.is_empty());
+ let link_share = record
+ .link_share
+ .as_deref()
+ .map(|value| {
+ LinkShare::from_str(value)
+ .map_err(|error| map_sqlx(AdapterError::Sqlx(sqlx::Error::Decode(Box::new(error)))))
+ })
+ .transpose()?;
+ Ok(SharePermissionV2 {
+ id: record.share_permission_id.clone(),
+ link_share,
+ link_share_access_level: record.link_share_access_level,
+ team_share_access_level: record.team_share_access_level,
+ owner: record.owner_user_id.clone(),
+ channel_share_permissions,
+ })
+}
+
+enum AdapterError {
+ Sqlx(sqlx::Error),
+ TeamShareCreate(rootcause::Report<TeamShareError>),
+ TeamShare(rootcause::Report<TeamShareError>),
+}
+
+fn map_sqlx(error: AdapterError) -> InitiativeError {
+ match error {
+ AdapterError::Sqlx(sqlx_error) => classify_sqlx(sqlx_error),
+ AdapterError::TeamShareCreate(error) => match error.current_context() {
+ TeamShareError::InvalidState => InitiativeError::BadRequest(
+ "initiative owner does not belong to a team".to_string(),
+ ),
+ other => classify_team_share(*other, error),
+ },
+ AdapterError::TeamShare(error) => {
+ let kind = *error.current_context();
+ classify_team_share(kind, error)
+ }
+ }
+}
+
+fn classify_sqlx(error: sqlx::Error) -> InitiativeError {
+ if let Some(db) = error.as_database_error() {
+ if db.is_unique_violation() {
+ return InitiativeError::Conflict("initiative already exists".to_string());
+ }
+ if is_initiative_member_fk(db) {
+ return InitiativeError::BadRequest("unknown member".to_string());
+ }
+ }
+ InitiativeError::Internal(error.into())
+}
+
+fn is_initiative_member_fk(db: &dyn sqlx::error::DatabaseError) -> bool {
+ if db.code().as_deref() != Some("23503") {
+ return false;
+ }
+ db.try_downcast_ref::<PgDatabaseError>().is_some_and(|pg| {
+ pg.table() == Some("initiative_member")
+ || pg
+ .constraint()
+ .is_some_and(|constraint| constraint.contains("initiative_member"))
+ })
+}
+
+fn classify_team_share(
+ kind: TeamShareError,
+ error: rootcause::Report<TeamShareError>,
+) -> InitiativeError {
+ match kind {
+ TeamShareError::NotFound => InitiativeError::NotFound,
+ TeamShareError::ChangedFacts | TeamShareError::UntrackedGrant => {
+ InitiativeError::Conflict(error.to_string())
+ }
+ _ => InitiativeError::Internal(error.into()),
+ }
+}
+
+fn entity_of(id: InitiativeId) -> Entity<'static> {
+ EntityType::Initiative.with_entity_string(id.as_uuid().to_string())
+}
+
+async fn load_record(
+ executor: impl Executor<'_, Database = Postgres>,
+ id: InitiativeId,
+) -> Result<Option<InitiativeRecord>, sqlx::Error> {
+ let id = id.as_uuid();
+ let row = sqlx::query!(
+ r#"
+ SELECT
+ i.id,
+ i.name,
+ i.description,
+ i.owner_user_id,
+ i.created_at,
+ i.updated_at,
+ i.share_permission_id,
+ COALESCE(
+ array_agg(DISTINCT m.user_id) FILTER (WHERE m.user_id IS NOT NULL),
+ '{}'::text[]
+ ) AS "member_ids!",
+ COALESCE(
+ array_agg(DISTINCT t.task_id) FILTER (WHERE t.task_id IS NOT NULL),
+ '{}'::text[]
+ ) AS "task_ids!",
+ sp."linkShare" AS "link_share?",
+ sp."linkShareAccessLevel" AS "link_share_access_level?: AccessLevel",
+ sp.team_share_access_level AS "team_share_access_level?: AccessLevel",
+ COALESCE(
+ (
+ SELECT json_agg(json_build_object(
+ 'channel_id', channel."channel_id",
+ 'access_level', channel."access_level"
+ ))
+ FROM "ChannelSharePermission" channel
+ WHERE channel."share_permission_id" = i.share_permission_id
+ ),
+ '[]'::json
+ ) AS "channel_share_permissions!"
+ FROM initiative i
+ JOIN "SharePermission" sp ON sp.id = i.share_permission_id
+ LEFT JOIN initiative_member m ON m.initiative_id = i.id
+ LEFT JOIN task_initiative t ON t.initiative_id = i.id
+ WHERE i.id = $1
+ GROUP BY
+ i.id,
+ i.name,
+ i.description,
+ i.owner_user_id,
+ i.created_at,
+ i.updated_at,
+ i.share_permission_id,
+ sp."linkShare",
+ sp."linkShareAccessLevel",
+ sp.team_share_access_level
+ "#,
+ id,
+ )
+ .fetch_optional(executor)
+ .await?;
+
+ Ok(row.map(|row| InitiativeRecord {
+ id: row.id,
+ name: row.name,
+ description: row.description,
+ owner_user_id: row.owner_user_id,
+ created_at: row.created_at,
+ updated_at: row.updated_at,
+ share_permission_id: row.share_permission_id,
+ member_ids: row.member_ids,
+ task_ids: row.task_ids,
+ link_share: row.link_share,
+ link_share_access_level: row.link_share_access_level,
+ team_share_access_level: row.team_share_access_level,
+ channel_share_permissions: row.channel_share_permissions,
+ }))
+}
+
+async fn require_detail(
+ executor: impl Executor<'_, Database = Postgres>,
+ id: InitiativeId,
+) -> Result<InitiativeDetail, InitiativeError> {
+ load_record(executor, id)
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?
+ .ok_or_else(|| {
+ InitiativeError::Internal(report!("initiative missing after successful write"))
+ })?
+ .into_detail()
+}
diff --git a/crates/initiative/src/outbound/pg_initiative_repo/create.rs b/crates/initiative/src/outbound/pg_initiative_repo/create.rs
new file mode 100644
index 0000000000..020f0dee8d
--- /dev/null
+++ b/crates/initiative/src/outbound/pg_initiative_repo/create.rs
@@ -0,0 +1,225 @@
+use entity_access_db_utils::{
+ AccessLevel, EntityAccessSourceType, EntityType, delete_entity_access_rows,
+ insert_entity_access_row,
+};
+use models_permissions::share_permission::SharePermissionV2;
+use models_permissions::share_permission::team_share::TeamShareCreation;
+use share_permission_db_utils::team_share;
+use sqlx::{PgPool, Postgres, Transaction};
+
+use super::{AdapterError, description_to_db, entity_of, map_sqlx, require_detail};
+use crate::domain::models::{
+ CreateInitiativeRepoArgs, InitiativeDetail, InitiativeError, InitiativeId,
+ UpdateInitiativeRepoArgs,
+};
+
+pub(super) async fn create(
+ pool: &PgPool,
+ args: CreateInitiativeRepoArgs,
+ share_permission: SharePermissionV2,
+ team_share: TeamShareCreation,
+) -> Result<InitiativeDetail, InitiativeError> {
+ let mut tx = pool
+ .begin()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ let id = args.id.as_uuid();
+ let entity = entity_of(args.id);
+
+ team_share::acquire_guard(&mut tx)
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ let share_permission_id =
+ super::share::insert_share_permission(&mut tx, &share_permission).await?;
+
+ sqlx::query!(
+ r#"
+ INSERT INTO initiative (
+ id,
+ name,
+ description,
+ owner_user_id,
+ share_permission_id
+ )
+ VALUES ($1, $2, $3, $4, $5)
+ "#,
+ id,
+ args.name,
+ description_to_db(args.description.as_deref()),
+ args.owner_id.as_ref(),
+ share_permission_id,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ super::members::insert_members(&mut tx, id, &args.member_ids).await?;
+
+ insert_entity_access_row(
+ &mut tx,
+ &id,
+ EntityType::Initiative,
+ args.owner_id.as_ref(),
+ EntityAccessSourceType::User,
+ AccessLevel::Owner,
+ )
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ super::members::grant_members_edit(&mut tx, id, &args.member_ids).await?;
+
+ team_share::initialize(&mut tx, &entity, team_share)
+ .await
+ .map_err(AdapterError::TeamShareCreate)
+ .map_err(map_sqlx)?;
+
+ tx.commit()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ require_detail(pool, args.id).await
+}
+
+pub(super) async fn update(
+ pool: &PgPool,
+ args: UpdateInitiativeRepoArgs,
+) -> Result<InitiativeDetail, InitiativeError> {
+ let mut tx = pool
+ .begin()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ let id = args.id.as_uuid();
+
+ if args.team_share.is_some() {
+ team_share::acquire_guard(&mut tx)
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ }
+
+ patch_initiative_row(&mut tx, &args).await?;
+ super::members::apply_member_diff(
+ &mut tx,
+ id,
+ &args.member_ids_added,
+ &args.member_ids_removed,
+ )
+ .await?;
+
+ if let Some(update) = &args.share_permission {
+ super::share::patch_share_permission(&mut tx, id, update).await?;
+ }
+
+ if let Some(command) = &args.team_share {
+ if command.expected().entity.entity_type != model_entity::EntityType::Initiative
+ || command.expected().entity.entity_id != args.id.to_string()
+ || args
+ .share_permission
+ .as_ref()
+ .and_then(|permission| permission.team_share_access_level)
+ != Some(command.target().map(|grant| grant.level.into()))
+ {
+ return Err(InitiativeError::BadRequest(
+ "team-share command does not match edit".to_string(),
+ ));
+ }
+ team_share::apply(&mut tx, command)
+ .await
+ .map_err(AdapterError::TeamShare)
+ .map_err(map_sqlx)?;
+ }
+
+ tx.commit()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ require_detail(pool, args.id).await
+}
+
+pub(super) async fn delete(pool: &PgPool, id: InitiativeId) -> Result<(), InitiativeError> {
+ let mut tx = pool
+ .begin()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ let uuid = id.as_uuid();
+
+ delete_entity_access_rows(&mut tx, &uuid, EntityType::Initiative)
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ let share_permission_id = sqlx::query_scalar!(
+ r#"
+ DELETE FROM initiative
+ WHERE id = $1
+ RETURNING share_permission_id
+ "#,
+ uuid,
+ )
+ .fetch_optional(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?
+ .ok_or(InitiativeError::NotFound)?;
+
+ sqlx::query!(
+ r#"
+ DELETE FROM "SharePermission"
+ WHERE id = $1
+ "#,
+ share_permission_id,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ tx.commit()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ Ok(())
+}
+
+async fn patch_initiative_row(
+ tx: &mut Transaction<'_, Postgres>,
+ args: &UpdateInitiativeRepoArgs,
+) -> Result<(), InitiativeError> {
+ let description_value = args
+ .description
+ .as_ref()
+ .map(|description| description_to_db(description.as_deref()))
+ .unwrap_or("");
+ let result = sqlx::query!(
+ r#"
+ UPDATE initiative
+ SET
+ name = CASE WHEN $2 THEN $3 ELSE name END,
+ description = CASE WHEN $4 THEN $5 ELSE description END,
+ updated_at = now()
+ WHERE id = $1
+ "#,
+ args.id.as_uuid(),
+ args.name.is_some(),
+ args.name.as_deref(),
+ args.description.is_some(),
+ description_value,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ if result.rows_affected() == 0 {
+ return Err(InitiativeError::NotFound);
+ }
+ Ok(())
+}
diff --git a/crates/initiative/src/outbound/pg_initiative_repo/list.rs b/crates/initiative/src/outbound/pg_initiative_repo/list.rs
new file mode 100644
index 0000000000..36a432daa9
--- /dev/null
+++ b/crates/initiative/src/outbound/pg_initiative_repo/list.rs
@@ -0,0 +1,67 @@
+use macro_user_id::user_id::MacroUserIdStr;
+use sqlx::PgPool;
+
+use super::{AdapterError, description_from_db, map_sqlx};
+use crate::domain::models::{InitiativeError, InitiativeId, InitiativeList, InitiativeSummary};
+
+pub(super) async fn list_accessible(
+ pool: &PgPool,
+ user_id: &MacroUserIdStr<'static>,
+) -> Result<InitiativeList, InitiativeError> {
+ let rows = sqlx::query!(
+ r#"
+ WITH user_source_ids AS (
+ SELECT cp.channel_id::text AS source_id
+ FROM comms_channel_participants cp
+ WHERE cp.user_id = $1 AND cp.left_at IS NULL
+ UNION ALL
+ SELECT t.team_id::text
+ FROM team_user t
+ WHERE t.user_id = $1
+ UNION ALL
+ SELECT $1
+ )
+ SELECT
+ i.id,
+ i.name,
+ i.description,
+ i.updated_at
+ FROM initiative i
+ JOIN "SharePermission" sp ON sp.id = i.share_permission_id
+ WHERE EXISTS (
+ SELECT 1
+ FROM entity_access ea
+ WHERE ea.entity_id = i.id
+ AND ea.entity_type = 'initiative'
+ AND ea.source_id IN (SELECT source_id FROM user_source_ids)
+ )
+ OR (
+ sp."linkShare" = 'TEAM'
+ AND EXISTS (
+ SELECT 1
+ FROM team_user owner_tu
+ WHERE owner_tu.user_id = i.owner_user_id
+ AND owner_tu.team_id::text IN (SELECT source_id FROM user_source_ids)
+ )
+ )
+ ORDER BY i.updated_at DESC
+ "#,
+ user_id.as_ref(),
+ )
+ .fetch_all(pool)
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ Ok(InitiativeList {
+ initiatives: rows
+ .into_iter()
+ .map(|row| InitiativeSummary {
+ id: InitiativeId::from_uuid(row.id),
+ name: row.name,
+ description: description_from_db(row.description),
+ updated_at: row.updated_at,
+ })
+ .collect(),
+ })
+}
diff --git a/crates/initiative/src/outbound/pg_initiative_repo/members.rs b/crates/initiative/src/outbound/pg_initiative_repo/members.rs
new file mode 100644
index 0000000000..287a520962
--- /dev/null
+++ b/crates/initiative/src/outbound/pg_initiative_repo/members.rs
@@ -0,0 +1,96 @@
+use entity_access_db_utils::{
+ AccessLevel, EntityType, delete_user_entity_access_rows, upsert_user_entity_access_bulk,
+};
+use macro_user_id::user_id::MacroUserIdStr;
+use sqlx::{Postgres, Transaction};
+use uuid::Uuid;
+
+use super::{AdapterError, map_sqlx};
+use crate::domain::models::InitiativeError;
+
+pub(super) async fn insert_members(
+ tx: &mut Transaction<'_, Postgres>,
+ id: Uuid,
+ member_ids: &[MacroUserIdStr<'static>],
+) -> Result<(), InitiativeError> {
+ if member_ids.is_empty() {
+ return Ok(());
+ }
+ let member_ids: Vec<String> = member_ids.iter().map(|id| id.to_string()).collect();
+ sqlx::query!(
+ r#"
+ INSERT INTO initiative_member (initiative_id, user_id)
+ SELECT $1, UNNEST($2::text[])
+ "#,
+ id,
+ &member_ids,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ Ok(())
+}
+
+pub(super) async fn grant_members_edit(
+ tx: &mut Transaction<'_, Postgres>,
+ id: Uuid,
+ member_ids: &[MacroUserIdStr<'static>],
+) -> Result<(), InitiativeError> {
+ upsert_user_entity_access_bulk(
+ tx.as_mut(),
+ member_ids,
+ &id,
+ EntityType::Initiative,
+ AccessLevel::Edit,
+ )
+ .await
+ .map_err(|error| InitiativeError::Internal(rootcause::report!("{error}")))
+}
+
+pub(super) async fn apply_member_diff(
+ tx: &mut Transaction<'_, Postgres>,
+ id: Uuid,
+ added: &[MacroUserIdStr<'static>],
+ removed: &[MacroUserIdStr<'static>],
+) -> Result<(), InitiativeError> {
+ if !removed.is_empty() {
+ let removed_ids: Vec<String> = removed.iter().map(|id| id.to_string()).collect();
+ sqlx::query!(
+ r#"
+ DELETE FROM initiative_member
+ WHERE initiative_id = $1 AND user_id = ANY($2)
+ "#,
+ id,
+ &removed_ids,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ delete_user_entity_access_rows(tx, &id, EntityType::Initiative, removed)
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ }
+
+ if !added.is_empty() {
+ let added_ids: Vec<String> = added.iter().map(|id| id.to_string()).collect();
+ sqlx::query!(
+ r#"
+ INSERT INTO initiative_member (initiative_id, user_id)
+ SELECT $1, UNNEST($2::text[])
+ ON CONFLICT DO NOTHING
+ "#,
+ id,
+ &added_ids,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ grant_members_edit(tx, id, added).await?;
+ }
+
+ Ok(())
+}
diff --git a/crates/initiative/src/outbound/pg_initiative_repo/share.rs b/crates/initiative/src/outbound/pg_initiative_repo/share.rs
new file mode 100644
index 0000000000..8292986684
--- /dev/null
+++ b/crates/initiative/src/outbound/pg_initiative_repo/share.rs
@@ -0,0 +1,264 @@
+use entity_access_db_utils::EntityType;
+use models_permissions::share_permission::channel_share_permission::UpdateOperation;
+use models_permissions::share_permission::team_share::TeamShareFacts;
+use models_permissions::share_permission::{
+ LinkShare, SharePermissionV2, TeamLinkShareDefault, UpdateSharePermissionRequestV2,
+ access_level::AccessLevel,
+};
+use share_permission_db_utils::{InsertChannelSharePermissionResult, team_share};
+use sqlx::{PgPool, Postgres, Transaction};
+use uuid::Uuid;
+
+use super::{AdapterError, entity_of, map_sqlx};
+use crate::domain::models::{InitiativeError, InitiativeId};
+
+pub(super) async fn insert_share_permission(
+ tx: &mut Transaction<'_, Postgres>,
+ permission: &SharePermissionV2,
+) -> Result<String, InitiativeError> {
+ let link_share = permission.link_share;
+ let link_share_access_level =
+ normalize_link_share_access_level(link_share, permission.link_share_access_level);
+ let link_share = link_share.map(|value| value.to_string());
+
+ let row = sqlx::query!(
+ r#"
+ INSERT INTO "SharePermission" (
+ "linkShare",
+ "linkShareAccessLevel",
+ "createdAt",
+ "updatedAt"
+ )
+ VALUES ($1, $2, NOW(), NOW())
+ RETURNING id
+ "#,
+ link_share,
+ link_share_access_level as _,
+ )
+ .fetch_one(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ for channel in permission.channel_share_permissions.iter().flatten() {
+ share_permission_db_utils::insert_channel_share_permission(
+ tx.as_mut(),
+ &row.id,
+ &channel.channel_id,
+ channel.access_level,
+ )
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ }
+
+ Ok(row.id)
+}
+
+pub(super) async fn patch_share_permission(
+ tx: &mut Transaction<'_, Postgres>,
+ initiative_id: Uuid,
+ update: &UpdateSharePermissionRequestV2,
+) -> Result<(), InitiativeError> {
+ let share_permission_id = sqlx::query_scalar!(
+ r#"
+ SELECT share_permission_id
+ FROM initiative
+ WHERE id = $1
+ "#,
+ initiative_id,
+ )
+ .fetch_optional(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?
+ .ok_or(InitiativeError::NotFound)?;
+
+ let update_link_share = update.link_share.is_some();
+ let link_share = update.link_share.flatten();
+ let (update_link_share_access_level, link_share_access_level) = match update.link_share {
+ Some(Some(_)) => (
+ true,
+ Some(link_share_access_level_or_default(
+ update.link_share_access_level.flatten(),
+ )),
+ ),
+ Some(None) => (true, None),
+ None => (
+ update.link_share_access_level.is_some(),
+ update.link_share_access_level.flatten(),
+ ),
+ };
+ let link_share = link_share.map(|value| value.to_string());
+
+ sqlx::query!(
+ r#"
+ UPDATE "SharePermission"
+ SET
+ "linkShare" = CASE WHEN $2 THEN $3 ELSE "linkShare" END,
+ "linkShareAccessLevel" = CASE
+ WHEN $2 AND $3 IS NULL THEN NULL
+ WHEN $2 THEN COALESCE($5::"AccessLevel", 'view')
+ WHEN $4 AND "linkShare" IS NOT NULL THEN COALESCE($5::"AccessLevel", 'view')
+ WHEN $4 THEN NULL
+ ELSE "linkShareAccessLevel"
+ END,
+ "updatedAt" = NOW()
+ WHERE id = $1
+ "#,
+ share_permission_id,
+ update_link_share,
+ link_share,
+ update_link_share_access_level,
+ link_share_access_level as _,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ let Some(channel_updates) = update.channel_share_permissions.as_ref() else {
+ return Ok(());
+ };
+
+ entity_access_db_utils::update_entity_access_channel_share_permissions(
+ tx,
+ &initiative_id,
+ EntityType::Initiative,
+ channel_updates,
+ )
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ for channel in channel_updates {
+ match channel.operation {
+ UpdateOperation::Add => {
+ let insert = share_permission_db_utils::insert_channel_share_permission(
+ tx.as_mut(),
+ &share_permission_id,
+ &channel.channel_id,
+ channel.access_level.unwrap_or(AccessLevel::View),
+ )
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ if insert == InsertChannelSharePermissionResult::AlreadyExists {
+ update_channel_share_access(
+ tx,
+ &share_permission_id,
+ &channel.channel_id,
+ channel.access_level.unwrap_or(AccessLevel::View),
+ )
+ .await?;
+ }
+ }
+ UpdateOperation::Remove => {
+ sqlx::query!(
+ r#"
+ DELETE FROM "ChannelSharePermission"
+ WHERE share_permission_id = $1 AND channel_id = $2
+ "#,
+ share_permission_id,
+ channel.channel_id,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ }
+ UpdateOperation::Replace => {
+ let updated = update_channel_share_access(
+ tx,
+ &share_permission_id,
+ &channel.channel_id,
+ channel.access_level.unwrap_or(AccessLevel::View),
+ )
+ .await?;
+ if !updated {
+ share_permission_db_utils::insert_channel_share_permission(
+ tx.as_mut(),
+ &share_permission_id,
+ &channel.channel_id,
+ channel.access_level.unwrap_or(AccessLevel::View),
+ )
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ }
+ }
+ }
+ }
+ Ok(())
+}
+
+async fn update_channel_share_access(
+ tx: &mut Transaction<'_, Postgres>,
+ share_permission_id: &str,
+ channel_id: &str,
+ access_level: AccessLevel,
+) -> Result<bool, InitiativeError> {
+ let result = sqlx::query!(
+ r#"
+ UPDATE "ChannelSharePermission"
+ SET access_level = $3::text::"AccessLevel"
+ WHERE share_permission_id = $1 AND channel_id = $2
+ "#,
+ share_permission_id,
+ channel_id,
+ access_level.to_string(),
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ Ok(result.rows_affected() > 0)
+}
+
+pub(super) async fn get_team_share_facts(
+ pool: &PgPool,
+ id: InitiativeId,
+) -> Result<TeamShareFacts, InitiativeError> {
+ let entity = entity_of(id);
+ let mut transaction = pool
+ .begin()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ let facts = team_share::load_facts(&mut transaction, &entity)
+ .await
+ .map_err(AdapterError::TeamShare)
+ .map_err(map_sqlx)?;
+ transaction
+ .commit()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ Ok(facts)
+}
+
+pub(super) async fn get_team_default_link_share(
+ pool: &PgPool,
+ user_id: &macro_user_id::user_id::MacroUserIdStr<'static>,
+) -> Result<Option<TeamLinkShareDefault>, InitiativeError> {
+ share_permission_db_utils::get_team_default_link_share(pool, user_id.as_ref())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)
+}
+
+fn link_share_access_level_or_default(link_share_access_level: Option<AccessLevel>) -> AccessLevel {
+ link_share_access_level.unwrap_or_else(|| {
+ tracing::warn!(
+ "link_share was enabled but link share access level was not provided, setting to view"
+ );
+ AccessLevel::View
+ })
+}
+
+fn normalize_link_share_access_level(
+ link_share: Option<LinkShare>,
+ link_share_access_level: Option<AccessLevel>,
+) -> Option<AccessLevel> {
+ link_share.map(|_| link_share_access_level_or_default(link_share_access_level))
+}
diff --git a/crates/initiative/src/outbound/pg_initiative_repo/tasks.rs b/crates/initiative/src/outbound/pg_initiative_repo/tasks.rs
new file mode 100644
index 0000000000..74a2481f60
--- /dev/null
+++ b/crates/initiative/src/outbound/pg_initiative_repo/tasks.rs
@@ -0,0 +1,193 @@
+use std::collections::{HashMap, HashSet};
+
+use sqlx::{PgPool, Postgres, Transaction};
+use uuid::Uuid;
+
+use super::{AdapterError, map_sqlx};
+use crate::domain::models::{AssignTaskStatus, AssignTasksResult, InitiativeError, InitiativeId};
+
+pub(super) async fn assign_tasks(
+ pool: &PgPool,
+ id: InitiativeId,
+ task_ids: Vec<String>,
+) -> Result<Vec<AssignTasksResult>, InitiativeError> {
+ if task_ids.is_empty() {
+ return Ok(Vec::new());
+ }
+
+ let mut tx = pool
+ .begin()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ let initiative_id = id.as_uuid();
+ lock_initiative(&mut tx, initiative_id).await?;
+
+ sqlx::query!(
+ r#"
+ SELECT id
+ FROM "Document"
+ WHERE id = ANY($1)
+ ORDER BY id
+ FOR UPDATE
+ "#,
+ &task_ids,
+ )
+ .fetch_all(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ let prior_rows = sqlx::query!(
+ r#"
+ SELECT task_id, initiative_id
+ FROM task_initiative
+ WHERE task_id = ANY($1)
+ FOR UPDATE
+ "#,
+ &task_ids,
+ )
+ .fetch_all(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ let prior: HashMap<String, Uuid> = prior_rows
+ .into_iter()
+ .map(|row| (row.task_id, row.initiative_id))
+ .collect();
+
+ let returned_rows = sqlx::query!(
+ r#"
+ INSERT INTO task_initiative (task_id, initiative_id)
+ SELECT dst.document_id, $1
+ FROM UNNEST($2::text[]) AS t(task_id)
+ JOIN document_sub_type dst
+ ON dst.document_id = t.task_id AND dst.sub_type = 'task'
+ ON CONFLICT (task_id) DO UPDATE
+ SET initiative_id = EXCLUDED.initiative_id, created_at = now()
+ RETURNING task_id
+ "#,
+ initiative_id,
+ &task_ids,
+ )
+ .fetch_all(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ let returned: HashSet<String> = returned_rows.into_iter().map(|row| row.task_id).collect();
+
+ sqlx::query!(
+ r#"
+ UPDATE initiative
+ SET updated_at = now()
+ WHERE id = $1
+ "#,
+ initiative_id,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ tx.commit()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ Ok(task_ids
+ .into_iter()
+ .map(|task_id| AssignTasksResult {
+ status: assign_status_for(&task_id, &prior, &returned, initiative_id),
+ task_id,
+ })
+ .collect())
+}
+
+pub(super) async fn unassign_task(
+ pool: &PgPool,
+ id: InitiativeId,
+ task_id: &str,
+) -> Result<(), InitiativeError> {
+ let mut tx = pool
+ .begin()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ let initiative_id = id.as_uuid();
+ lock_initiative(&mut tx, initiative_id).await?;
+ let result = sqlx::query!(
+ r#"
+ DELETE FROM task_initiative
+ WHERE task_id = $1 AND initiative_id = $2
+ "#,
+ task_id,
+ initiative_id,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ if result.rows_affected() == 0 {
+ return Err(InitiativeError::NotFound);
+ }
+
+ sqlx::query!(
+ r#"
+ UPDATE initiative
+ SET updated_at = now()
+ WHERE id = $1
+ "#,
+ initiative_id,
+ )
+ .execute(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+
+ tx.commit()
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ Ok(())
+}
+
+async fn lock_initiative(
+ tx: &mut Transaction<'_, Postgres>,
+ initiative_id: Uuid,
+) -> Result<(), InitiativeError> {
+ let locked = sqlx::query_scalar!(
+ r#"
+ SELECT id
+ FROM initiative
+ WHERE id = $1
+ FOR UPDATE
+ "#,
+ initiative_id,
+ )
+ .fetch_optional(tx.as_mut())
+ .await
+ .map_err(AdapterError::Sqlx)
+ .map_err(map_sqlx)?;
+ if locked.is_none() {
+ return Err(InitiativeError::NotFound);
+ }
+ Ok(())
+}
+
+fn assign_status_for(
+ task_id: &str,
+ prior: &HashMap<String, Uuid>,
+ returned: &HashSet<String>,
+ this_initiative: Uuid,
+) -> AssignTaskStatus {
+ if !returned.contains(task_id) {
+ return AssignTaskStatus::NotATask;
+ }
+ match prior.get(task_id) {
+ Some(owner) if *owner != this_initiative => AssignTaskStatus::Moved,
+ _ => AssignTaskStatus::Assigned,
+ }
+}
diff --git a/crates/initiative/src/outbound/pg_initiative_repo/test.rs b/crates/initiative/src/outbound/pg_initiative_repo/test.rs
new file mode 100644
index 0000000000..d2d26eb98c
--- /dev/null
+++ b/crates/initiative/src/outbound/pg_initiative_repo/test.rs
@@ -0,0 +1,684 @@
+use entity_access_db_utils::AccessLevel;
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use macro_user_id::cowlike::CowLike;
+use macro_user_id::user_id::MacroUserIdStr;
+use models_permissions::share_permission::channel_share_permission::{
+ ChannelSharePermission, UpdateChannelSharePermission, UpdateOperation,
+};
+use models_permissions::share_permission::team_share::TeamShareCreation;
+use models_permissions::share_permission::{
+ LinkShare, SharePermissionV2, UpdateSharePermissionRequestV2,
+};
+use sqlx::PgPool;
+use uuid::Uuid;
+
+use super::PgInitiativeRepo;
+use crate::domain::models::{
+ AssignTaskStatus, CreateInitiativeRepoArgs, InitiativeError, InitiativeId,
+ UpdateInitiativeRepoArgs,
+};
+use crate::domain::ports::InitiativeRepo;
+
+const OWNER: &str = "macro|[email protected]";
+const MEMBER: &str = "macro|[email protected]";
+const TEAMMATE: &str = "macro|[email protected]";
+const CHANNEL_USER: &str = "macro|[email protected]";
+const STRANGER: &str = "macro|[email protected]";
+const OTHER_OWNER: &str = "macro|[email protected]";
+
+fn user(id: &str) -> MacroUserIdStr<'static> {
+ MacroUserIdStr::parse_from_str(id)
+ .expect("valid user id")
+ .into_owned()
+}
+
+fn repo(pool: PgPool) -> PgInitiativeRepo {
+ PgInitiativeRepo::new(pool)
+}
+
+fn share_off() -> SharePermissionV2 {
+ SharePermissionV2::new_initiative_share_permission(None)
+}
+
+fn share_link(link: LinkShare) -> SharePermissionV2 {
+ let mut permission = share_off();
+ permission.link_share = Some(link);
+ permission.link_share_access_level = Some(AccessLevel::View);
+ permission
+}
+
+fn create_args(owner: &str, name: &str, members: &[&str]) -> CreateInitiativeRepoArgs {
+ CreateInitiativeRepoArgs {
+ id: InitiativeId::generate(),
+ owner_id: user(owner),
+ name: name.to_string(),
+ description: None,
+ member_ids: members.iter().copied().map(user).collect(),
+ }
+}
+
+async fn insert_user(pool: &PgPool, user_id: &str) -> anyhow::Result<()> {
+ let macro_user_id = Uuid::now_v7();
+ let email = user_id.trim_start_matches("macro|");
+ sqlx::query!(
+ r#"
+ INSERT INTO macro_user (id, username, email, stripe_customer_id)
+ VALUES ($1, $2, $3, $2)
+ "#,
+ macro_user_id,
+ user_id,
+ email,
+ )
+ .execute(pool)
+ .await?;
+ sqlx::query!(
+ r#"INSERT INTO "User" (id, email, macro_user_id) VALUES ($1, $2, $3)"#,
+ user_id,
+ email,
+ macro_user_id,
+ )
+ .execute(pool)
+ .await?;
+ Ok(())
+}
+
+async fn insert_team(pool: &PgPool, team_id: Uuid, owner_id: &str) -> anyhow::Result<()> {
+ sqlx::query!(
+ r#"INSERT INTO team (id, name, owner_id) VALUES ($1, 'Initiative Repo Team', $2)"#,
+ team_id,
+ owner_id,
+ )
+ .execute(pool)
+ .await?;
+ Ok(())
+}
+
+async fn add_team_user(
+ pool: &PgPool,
+ team_id: Uuid,
+ user_id: &str,
+ role: &str,
+) -> anyhow::Result<()> {
+ sqlx::query!(
+ r#"
+ INSERT INTO team_user (user_id, team_id, team_role)
+ VALUES ($1, $2, $3::text::team_role)
+ "#,
+ user_id,
+ team_id,
+ role,
+ )
+ .execute(pool)
+ .await?;
+ Ok(())
+}
+
+async fn insert_channel(
+ pool: &PgPool,
+ channel_id: Uuid,
+ owner_id: &str,
+ participant_id: &str,
+) -> anyhow::Result<()> {
+ sqlx::query!(
+ r#"
+ INSERT INTO comms_channels (id, name, channel_type, owner_id)
+ VALUES ($1, 'Initiative channel', 'public', $2)
+ "#,
+ channel_id,
+ owner_id,
+ )
+ .execute(pool)
+ .await?;
+ sqlx::query!(
+ r#"
+ INSERT INTO comms_channel_participants (channel_id, role, user_id)
+ VALUES ($1, 'member', $2)
+ "#,
+ channel_id,
+ participant_id,
+ )
+ .execute(pool)
+ .await?;
+ Ok(())
+}
+
+async fn insert_document(pool: &PgPool, id: &str, owner: &str, task: bool) -> anyhow::Result<()> {
+ sqlx::query!(
+ r#"INSERT INTO "Document" (id, name, "fileType", owner) VALUES ($1, $2, 'md', $3)"#,
+ id,
+ id,
+ owner,
+ )
+ .execute(pool)
+ .await?;
+ if task {
+ sqlx::query!(
+ r#"INSERT INTO document_sub_type (document_id, sub_type) VALUES ($1, 'task')"#,
+ id,
+ )
+ .execute(pool)
+ .await?;
+ }
+ Ok(())
+}
+
+async fn access_level(
+ pool: &PgPool,
+ initiative_id: Uuid,
+ source_id: &str,
+) -> anyhow::Result<Option<String>> {
+ let row = sqlx::query_scalar!(
+ r#"
+ SELECT access_level::text
+ FROM entity_access
+ WHERE entity_id = $1
+ AND entity_type = 'initiative'
+ AND source_id = $2
+ AND granted_from_project_id IS NULL
+ "#,
+ initiative_id,
+ source_id,
+ )
+ .fetch_optional(pool)
+ .await?;
+ Ok(row.flatten())
+}
+
+fn ids(list: &crate::domain::models::InitiativeList) -> Vec<Uuid> {
+ list.initiatives
+ .iter()
+ .map(|summary| summary.id.as_uuid())
+ .collect()
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn create_writes_initiative_share_owner_members_and_optional_team_grant(
+ pool: PgPool,
+) -> anyhow::Result<()> {
+ insert_user(&pool, OWNER).await?;
+ insert_user(&pool, MEMBER).await?;
+ let team_id = Uuid::now_v7();
+ insert_team(&pool, team_id, OWNER).await?;
+ add_team_user(&pool, team_id, OWNER, "owner").await?;
+ add_team_user(&pool, team_id, MEMBER, "member").await?;
+
+ let repo = repo(pool.clone());
+ let args = CreateInitiativeRepoArgs {
+ description: Some("Ship it".to_string()),
+ ..create_args(OWNER, "Launch", &[MEMBER])
+ };
+ let id = args.id;
+ let detail = repo
+ .create(args, share_off(), TeamShareCreation::Initiative)
+ .await?;
+
+ assert_eq!(detail.name, "Launch");
+ assert_eq!(detail.description.as_deref(), Some("Ship it"));
+ assert_eq!(detail.owner_id.as_ref(), OWNER);
+ assert_eq!(
+ detail
+ .member_ids
+ .iter()
+ .map(|id| id.as_ref())
+ .collect::<Vec<_>>(),
+ vec![MEMBER]
+ );
+ assert!(!detail.share_permission.id.is_empty());
+ assert_eq!(
+ detail.share_permission.team_share_access_level,
+ Some(AccessLevel::Edit)
+ );
+ assert_eq!(detail.user_access_level, AccessLevel::View);
+
+ let share_exists = sqlx::query_scalar!(
+ r#"SELECT EXISTS(SELECT 1 FROM "SharePermission" WHERE id = $1) AS "exists!""#,
+ detail.share_permission.id,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert!(share_exists);
+
+ assert_eq!(
+ access_level(&pool, id.as_uuid(), OWNER).await?.as_deref(),
+ Some("owner")
+ );
+ assert_eq!(
+ access_level(&pool, id.as_uuid(), MEMBER).await?.as_deref(),
+ Some("edit")
+ );
+ assert_eq!(
+ access_level(&pool, id.as_uuid(), &team_id.to_string())
+ .await?
+ .as_deref(),
+ Some("edit")
+ );
+
+ let basic = repo.get_basic(id).await?.expect("created initiative");
+ assert_eq!(basic.name, "Launch");
+ assert_eq!(basic.owner_id.as_ref(), OWNER);
+ Ok(())
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn get_detail_reports_each_channel_grant_once(pool: PgPool) -> anyhow::Result<()> {
+ insert_user(&pool, OWNER).await?;
+ insert_user(&pool, MEMBER).await?;
+ insert_user(&pool, TEAMMATE).await?;
+ let channel_id = Uuid::now_v7();
+ insert_channel(&pool, channel_id, OWNER, MEMBER).await?;
+ let task_a = Uuid::now_v7().to_string();
+ let task_b = Uuid::now_v7().to_string();
+ insert_document(&pool, &task_a, OWNER, true).await?;
+ insert_document(&pool, &task_b, OWNER, true).await?;
+
+ let repo = repo(pool);
+ let created = repo
+ .create(
+ create_args(OWNER, "Busy", &[MEMBER, TEAMMATE]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+ repo.update(UpdateInitiativeRepoArgs {
+ id: created.id,
+ name: None,
+ description: None,
+ member_ids_added: Vec::new(),
+ member_ids_removed: Vec::new(),
+ share_permission: Some(UpdateSharePermissionRequestV2 {
+ link_share: None,
+ link_share_access_level: None,
+ team_share_access_level: None,
+ channel_share_permissions: Some(vec![UpdateChannelSharePermission {
+ operation: UpdateOperation::Add,
+ channel_id: channel_id.to_string(),
+ access_level: Some(AccessLevel::View),
+ }]),
+ }),
+ team_share: None,
+ })
+ .await?;
+ repo.assign_tasks(created.id, vec![task_a.clone(), task_b.clone()])
+ .await?;
+
+ let detail = repo.get_detail(created.id).await?.expect("busy");
+ assert_eq!(
+ detail.share_permission.channel_share_permissions,
+ Some(vec![ChannelSharePermission {
+ channel_id: channel_id.to_string(),
+ access_level: AccessLevel::View,
+ }])
+ );
+ Ok(())
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn create_share_with_team_without_owner_team_is_bad_request(
+ pool: PgPool,
+) -> anyhow::Result<()> {
+ insert_user(&pool, OWNER).await?;
+ let repo = repo(pool);
+ let error = repo
+ .create(
+ create_args(OWNER, "Solo", &[]),
+ share_off(),
+ TeamShareCreation::Initiative,
+ )
+ .await
+ .expect_err("teamless owner cannot share with team");
+ assert!(matches!(error, InitiativeError::BadRequest(message) if message.contains("team")));
+ Ok(())
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn list_accessible_includes_owner_member_team_channel_and_team_link(
+ pool: PgPool,
+) -> anyhow::Result<()> {
+ insert_user(&pool, OWNER).await?;
+ insert_user(&pool, MEMBER).await?;
+ insert_user(&pool, TEAMMATE).await?;
+ insert_user(&pool, CHANNEL_USER).await?;
+ let team_id = Uuid::now_v7();
+ insert_team(&pool, team_id, OWNER).await?;
+ add_team_user(&pool, team_id, OWNER, "owner").await?;
+ add_team_user(&pool, team_id, TEAMMATE, "member").await?;
+ let channel_id = Uuid::now_v7();
+ insert_channel(&pool, channel_id, OWNER, CHANNEL_USER).await?;
+
+ let repo = repo(pool.clone());
+ let owned = repo
+ .create(
+ create_args(OWNER, "Owned", &[MEMBER]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+ let team_granted = repo
+ .create(
+ create_args(OWNER, "Team granted", &[]),
+ share_off(),
+ TeamShareCreation::Initiative,
+ )
+ .await?;
+ let team_link = repo
+ .create(
+ create_args(OWNER, "Team link", &[]),
+ share_link(LinkShare::Team),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+ let channel_shared = repo
+ .create(
+ create_args(OWNER, "Channel", &[]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+ repo.update(UpdateInitiativeRepoArgs {
+ id: channel_shared.id,
+ name: None,
+ description: None,
+ member_ids_added: Vec::new(),
+ member_ids_removed: Vec::new(),
+ share_permission: Some(UpdateSharePermissionRequestV2 {
+ link_share: None,
+ link_share_access_level: None,
+ team_share_access_level: None,
+ channel_share_permissions: Some(vec![UpdateChannelSharePermission {
+ operation: UpdateOperation::Add,
+ channel_id: channel_id.to_string(),
+ access_level: Some(AccessLevel::View),
+ }]),
+ }),
+ team_share: None,
+ })
+ .await?;
+
+ let owner_list = ids(&repo.list_accessible(&user(OWNER)).await?);
+ let member_list = ids(&repo.list_accessible(&user(MEMBER)).await?);
+ let teammate_list = ids(&repo.list_accessible(&user(TEAMMATE)).await?);
+ let channel_list = ids(&repo.list_accessible(&user(CHANNEL_USER)).await?);
+
+ assert!(owner_list.contains(&owned.id.as_uuid()));
+ assert!(member_list.contains(&owned.id.as_uuid()));
+ assert!(teammate_list.contains(&team_granted.id.as_uuid()));
+ assert!(teammate_list.contains(&team_link.id.as_uuid()));
+ assert!(channel_list.contains(&channel_shared.id.as_uuid()));
+ Ok(())
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn list_accessible_excludes_public_only_and_unrelated(pool: PgPool) -> anyhow::Result<()> {
+ insert_user(&pool, OWNER).await?;
+ insert_user(&pool, STRANGER).await?;
+ insert_user(&pool, OTHER_OWNER).await?;
+
+ let repo = repo(pool);
+ let public_only = repo
+ .create(
+ create_args(OWNER, "Public only", &[]),
+ share_link(LinkShare::Public),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+ let unrelated = repo
+ .create(
+ create_args(OTHER_OWNER, "Unrelated", &[]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+
+ let stranger_list = ids(&repo.list_accessible(&user(STRANGER)).await?);
+ assert!(!stranger_list.contains(&public_only.id.as_uuid()));
+ assert!(!stranger_list.contains(&unrelated.id.as_uuid()));
+ Ok(())
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn update_removing_member_deletes_only_that_grant(pool: PgPool) -> anyhow::Result<()> {
+ insert_user(&pool, OWNER).await?;
+ insert_user(&pool, MEMBER).await?;
+ insert_user(&pool, TEAMMATE).await?;
+
+ let repo = repo(pool.clone());
+ let created = repo
+ .create(
+ create_args(OWNER, "Members", &[MEMBER, TEAMMATE]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+
+ let updated = repo
+ .update(UpdateInitiativeRepoArgs {
+ id: created.id,
+ name: Some("Renamed".to_string()),
+ description: Some(None),
+ member_ids_added: Vec::new(),
+ member_ids_removed: vec![user(MEMBER)],
+ share_permission: None,
+ team_share: None,
+ })
+ .await?;
+
+ assert_eq!(updated.name, "Renamed");
+ assert_eq!(updated.description, None);
+ assert_eq!(
+ updated
+ .member_ids
+ .iter()
+ .map(|id| id.as_ref())
+ .collect::<Vec<_>>(),
+ vec![TEAMMATE]
+ );
+ assert_eq!(
+ access_level(&pool, created.id.as_uuid(), OWNER)
+ .await?
+ .as_deref(),
+ Some("owner")
+ );
+ assert_eq!(
+ access_level(&pool, created.id.as_uuid(), MEMBER).await?,
+ None
+ );
+ assert_eq!(
+ access_level(&pool, created.id.as_uuid(), TEAMMATE)
+ .await?
+ .as_deref(),
+ Some("edit")
+ );
+ Ok(())
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn assign_tasks_moves_and_reports_non_tasks(pool: PgPool) -> anyhow::Result<()> {
+ insert_user(&pool, OWNER).await?;
+ let task_a = Uuid::now_v7().to_string();
+ let task_b = Uuid::now_v7().to_string();
+ let not_a_task = Uuid::now_v7().to_string();
+ let missing = Uuid::now_v7().to_string();
+ insert_document(&pool, &task_a, OWNER, true).await?;
+ insert_document(&pool, &task_b, OWNER, true).await?;
+ insert_document(&pool, &not_a_task, OWNER, false).await?;
+
+ let repo = repo(pool);
+ let first = repo
+ .create(
+ create_args(OWNER, "First", &[]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+ let second = repo
+ .create(
+ create_args(OWNER, "Second", &[]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+
+ let first_results = repo
+ .assign_tasks(first.id, vec![task_a.clone(), task_b.clone()])
+ .await?;
+ assert_eq!(
+ first_results
+ .iter()
+ .map(|result| result.status)
+ .collect::<Vec<_>>(),
+ vec![AssignTaskStatus::Assigned, AssignTaskStatus::Assigned]
+ );
+
+ let second_results = repo
+ .assign_tasks(
+ second.id,
+ vec![task_a.clone(), not_a_task.clone(), missing.clone()],
+ )
+ .await?;
+ assert_eq!(second_results[0].status, AssignTaskStatus::Moved);
+ assert_eq!(second_results[1].status, AssignTaskStatus::NotATask);
+ assert_eq!(second_results[2].status, AssignTaskStatus::NotATask);
+
+ let first_detail = repo.get_detail(first.id).await?.expect("first");
+ let second_detail = repo.get_detail(second.id).await?.expect("second");
+ assert_eq!(first_detail.task_ids, vec![task_b.clone()]);
+ assert_eq!(second_detail.task_ids, vec![task_a.clone()]);
+ assert!(second_detail.updated_at > second.updated_at);
+ assert!(matches!(
+ repo.assign_tasks(InitiativeId::generate(), vec![task_a])
+ .await,
+ Err(InitiativeError::NotFound)
+ ));
+ Ok(())
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn unassign_task_ignores_links_owned_by_other_initiatives(
+ pool: PgPool,
+) -> anyhow::Result<()> {
+ insert_user(&pool, OWNER).await?;
+ let task_id = Uuid::now_v7().to_string();
+ insert_document(&pool, &task_id, OWNER, true).await?;
+
+ let repo = repo(pool);
+ let first = repo
+ .create(
+ create_args(OWNER, "Keeper", &[]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+ let second = repo
+ .create(
+ create_args(OWNER, "Other", &[]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+ repo.assign_tasks(first.id, vec![task_id.clone()]).await?;
+
+ let error = repo
+ .unassign_task(second.id, &task_id)
+ .await
+ .expect_err("other initiative cannot steal the link");
+ assert!(matches!(error, InitiativeError::NotFound));
+
+ repo.unassign_task(first.id, &task_id).await?;
+ let detail = repo.get_detail(first.id).await?.expect("keeper");
+ assert!(detail.task_ids.is_empty());
+ assert!(detail.updated_at > first.updated_at);
+ Ok(())
+}
+
+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
+async fn delete_leaves_no_share_permission_channel_share_entity_access_member_or_task_rows(
+ pool: PgPool,
+) -> anyhow::Result<()> {
+ insert_user(&pool, OWNER).await?;
+ insert_user(&pool, MEMBER).await?;
+ let channel_id = Uuid::now_v7();
+ insert_channel(&pool, channel_id, OWNER, MEMBER).await?;
+ let task_id = Uuid::now_v7().to_string();
+ insert_document(&pool, &task_id, OWNER, true).await?;
+
+ let repo = repo(pool.clone());
+ let created = repo
+ .create(
+ create_args(OWNER, "To delete", &[MEMBER]),
+ share_off(),
+ TeamShareCreation::Unshared,
+ )
+ .await?;
+ repo.update(UpdateInitiativeRepoArgs {
+ id: created.id,
+ name: None,
+ description: None,
+ member_ids_added: Vec::new(),
+ member_ids_removed: Vec::new(),
+ share_permission: Some(UpdateSharePermissionRequestV2 {
+ link_share: None,
+ link_share_access_level: None,
+ team_share_access_level: None,
+ channel_share_permissions: Some(vec![UpdateChannelSharePermission {
+ operation: UpdateOperation::Add,
+ channel_id: channel_id.to_string(),
+ access_level: Some(AccessLevel::View),
+ }]),
+ }),
+ team_share: None,
+ })
+ .await?;
+ repo.assign_tasks(created.id, vec![task_id.clone()]).await?;
+ let share_id = created.share_permission.id.clone();
+ let initiative_id = created.id.as_uuid();
+
+ repo.delete(created.id).await?;
+
+ let leftover_share = sqlx::query_scalar!(
+ r#"SELECT EXISTS(SELECT 1 FROM "SharePermission" WHERE id = $1) AS "exists!""#,
+ share_id,
+ )
+ .fetch_one(&pool)
+ .await?;
+ let leftover_channel = sqlx::query_scalar!(
+ r#"
+ SELECT EXISTS(
+ SELECT 1 FROM "ChannelSharePermission" WHERE share_permission_id = $1
+ ) AS "exists!"
+ "#,
+ share_id,
+ )
+ .fetch_one(&pool)
+ .await?;
+ let leftover_access = sqlx::query_scalar!(
+ r#"
+ SELECT EXISTS(
+ SELECT 1 FROM entity_access
+ WHERE entity_id = $1 AND entity_type = 'initiative'
+ ) AS "exists!"
+ "#,
+ initiative_id,
+ )
+ .fetch_one(&pool)
+ .await?;
+ let leftover_member = sqlx::query_scalar!(
+ r#"SELECT EXISTS(SELECT 1 FROM initiative_member WHERE initiative_id = $1) AS "exists!""#,
+ initiative_id,
+ )
+ .fetch_one(&pool)
+ .await?;
+ let leftover_task = sqlx::query_scalar!(
+ r#"SELECT EXISTS(SELECT 1 FROM task_initiative WHERE initiative_id = $1) AS "exists!""#,
+ initiative_id,
+ )
+ .fetch_one(&pool)
+ .await?;
+
+ assert!(!leftover_share);
+ assert!(!leftover_channel);
+ assert!(!leftover_access);
+ assert!(!leftover_member);
+ assert!(!leftover_task);
+ assert!(repo.get_detail(created.id).await?.is_none());
+ Ok(())
+}