Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat(initiative): add PgInitiativeRepo and sqlx tests (#6449)
Will Hutchinson487d23a0c2a4
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.lockindex 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.tomlindex b634c10aa1..489d569302 100644--- a/crates/initiative/Cargo.toml+++ b/crates/initiative/Cargo.toml@@ -5,7 +5,7 @@ publish = falseversion = "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.rsindex 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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: ¯o_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.rsnew file mode 100644index 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.rsnew file mode 100644index 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, ¬_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(())+}