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 hexify projects (#4934)

Will Hutchinson5a56b28c4964
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.json
index 2f221f72cd..3b84e25820 100644
--- a/.github/workspace-dep-closures.json
+++ b/.github/workspace-dep-closures.json
@@ -1552,7 +1552,6 @@
"crates/macro_event_broker",
"crates/macro_event_topics",
"crates/macro_middleware",
- "crates/macro_project_utils",
"crates/macro_queues",
"crates/macro_service_urls",
"crates/macro_sha_count_client",
@@ -1586,6 +1585,7 @@
"crates/notification",
"crates/opensearch_client",
"crates/opensearch_query_builder",
+ "crates/projects",
"crates/prompt",
"crates/properties",
"crates/properties_service",
@@ -3276,65 +3276,6 @@
"crates/user_quota",
"crates/workspace-hack"
],
- "macro_project_utils": [
- "crates/agent",
- "crates/ai_toolset",
- "crates/ai_usage",
- "crates/attachment",
- "crates/authentication_service_client",
- "crates/bot_id",
- "crates/channel_sender",
- "crates/cowlike",
- "crates/crm",
- "crates/decode_jwt",
- "crates/document_sub_type",
- "crates/email",
- "crates/email_db_client",
- "crates/email_utils",
- "crates/entity_access",
- "crates/entity_access_db_utils",
- "crates/entity_access_management",
- "crates/filter_ast",
- "crates/frecency",
- "crates/invite_email",
- "crates/item_filters",
- "crates/last_online_tracker",
- "crates/macro_auth",
- "crates/macro_authorization",
- "crates/macro_env",
- "crates/macro_env_var",
- "crates/macro_event_broker",
- "crates/macro_event_topics",
- "crates/macro_project_utils",
- "crates/macro_service_urls",
- "crates/macro_user_id",
- "crates/macro_uuid",
- "crates/mention_utils",
- "crates/model",
- "crates/model-entity",
- "crates/model-error-response",
- "crates/model_file_type",
- "crates/model_notifications",
- "crates/model_user",
- "crates/models_ai_projection",
- "crates/models_bulk_upload",
- "crates/models_email",
- "crates/models_entity_access_management",
- "crates/models_pagination",
- "crates/models_permissions",
- "crates/models_properties",
- "crates/non_empty",
- "crates/notification",
- "crates/prompt",
- "crates/properties",
- "crates/rate_limit",
- "crates/remote_env_var",
- "crates/s3_key",
- "crates/sqs_client",
- "crates/system_properties",
- "crates/unfurl",
- "crates/workspace-hack"
- ],
"macro_queues": [
"crates/macro_env",
"crates/macro_env_var",
@@ -4216,6 +4157,68 @@
"crates/workspace-hack",
"services/organization_retention_trigger"
],
+ "projects": [
+ "crates/agent",
+ "crates/ai_toolset",
+ "crates/ai_usage",
+ "crates/attachment",
+ "crates/authentication_service_client",
+ "crates/bot_id",
+ "crates/channel_sender",
+ "crates/cowlike",
+ "crates/crm",
+ "crates/decode_jwt",
+ "crates/document_sub_type",
+ "crates/dynamodb_client",
+ "crates/email",
+ "crates/email_db_client",
+ "crates/email_utils",
+ "crates/entity_access",
+ "crates/entity_access_db_utils",
+ "crates/entity_access_management",
+ "crates/filter_ast",
+ "crates/frecency",
+ "crates/invite_email",
+ "crates/item_filters",
+ "crates/last_online_tracker",
+ "crates/macro_auth",
+ "crates/macro_authorization",
+ "crates/macro_aws_config",
+ "crates/macro_env",
+ "crates/macro_env_var",
+ "crates/macro_event_broker",
+ "crates/macro_event_topics",
+ "crates/macro_service_urls",
+ "crates/macro_sha_count_client",
+ "crates/macro_user_id",
+ "crates/macro_uuid",
+ "crates/mention_utils",
+ "crates/model",
+ "crates/model-entity",
+ "crates/model-error-response",
+ "crates/model_file_type",
+ "crates/model_notifications",
+ "crates/model_user",
+ "crates/models_ai_projection",
+ "crates/models_bulk_upload",
+ "crates/models_email",
+ "crates/models_entity_access_management",
+ "crates/models_pagination",
+ "crates/models_permissions",
+ "crates/models_properties",
+ "crates/non_empty",
+ "crates/notification",
+ "crates/projects",
+ "crates/prompt",
+ "crates/properties",
+ "crates/rate_limit",
+ "crates/remote_env_var",
+ "crates/s3_key",
+ "crates/sqs_client",
+ "crates/system_properties",
+ "crates/unfurl",
+ "crates/workspace-hack"
+ ],
"prompt": [
"crates/prompt",
"crates/workspace-hack"
diff --git a/.sqlx/query-030974957f30c1fc16d1a6bed0ffc3dcd6d71b2c0029f7f7fa3ef3285e12a8f5.json b/.sqlx/query-030974957f30c1fc16d1a6bed0ffc3dcd6d71b2c0029f7f7fa3ef3285e12a8f5.json
deleted file mode 100644
index 7cbe7bbe84..0000000000
--- a/.sqlx/query-030974957f30c1fc16d1a6bed0ffc3dcd6d71b2c0029f7f7fa3ef3285e12a8f5.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n DELETE FROM \"UserHistory\" WHERE \"itemId\" = ANY($1)\n ",
- "describe": {
- "columns": [],
- "parameters": {
- "Left": [
- "TextArray"
- ]
- },
- "nullable": []
- },
- "hash": "030974957f30c1fc16d1a6bed0ffc3dcd6d71b2c0029f7f7fa3ef3285e12a8f5"
-}
diff --git a/.sqlx/query-033759a1748c41359a8cf5204f457eed63182d21b432b58fd25b7524d1dc0092.json b/.sqlx/query-033759a1748c41359a8cf5204f457eed63182d21b432b58fd25b7524d1dc0092.json
deleted file mode 100644
index a7919cb370..0000000000
--- a/.sqlx/query-033759a1748c41359a8cf5204f457eed63182d21b432b58fd25b7524d1dc0092.json
+++ /dev/null
@@ -1,88 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n SELECT\n d.id as document_id,\n d.owner as owner,\n d.name as document_name,\n COALESCE(db.id, di.id) as \"document_version_id!\",\n d.\"fileType\" as \"file_type?\",\n d.\"createdAt\"::timestamptz as created_at,\n d.\"updatedAt\"::timestamptz as updated_at,\n d.\"projectId\" as \"project_id?\",\n dt.sub_type as \"sub_type?: DocumentSubType\",\n CASE \n WHEN dt.sub_type = 'task' \n AND ep_status.values->'value' ? $2\n THEN true \n WHEN dt.sub_type = 'task'\n THEN false\n ELSE NULL \n END as \"is_completed\"\n FROM\n \"Document\" d\n LEFT JOIN document_sub_type dt ON dt.document_id = d.id\n LEFT JOIN entity_properties ep_status \n ON dt.sub_type = 'task'\n AND ep_status.entity_id = d.id \n AND ep_status.entity_type = 'TASK'\n AND ep_status.property_definition_id = $3\n LEFT JOIN LATERAL (\n SELECT\n b.id\n FROM\n \"DocumentBom\" b\n WHERE\n b.\"documentId\" = d.id\n ORDER BY\n b.\"createdAt\" DESC\n LIMIT 1\n ) db ON d.\"fileType\" = 'docx'\n LEFT JOIN LATERAL (\n SELECT\n i.id,\n i.\"documentId\",\n i.\"createdAt\",\n i.\"updatedAt\"\n FROM\n \"DocumentInstance\" i\n WHERE\n i.\"documentId\" = d.id\n ORDER BY\n i.\"updatedAt\" DESC\n LIMIT 1\n ) di ON d.\"fileType\" IS DISTINCT FROM 'docx'\n WHERE d.\"projectId\" = $1 AND d.\"deletedAt\" IS NULL\n ",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "document_id",
- "type_info": "Text"
- },
- {
- "ordinal": 1,
- "name": "owner",
- "type_info": "Text"
- },
- {
- "ordinal": 2,
- "name": "document_name",
- "type_info": "Text"
- },
- {
- "ordinal": 3,
- "name": "document_version_id!",
- "type_info": "Int8"
- },
- {
- "ordinal": 4,
- "name": "file_type?",
- "type_info": "Text"
- },
- {
- "ordinal": 5,
- "name": "created_at",
- "type_info": "Timestamptz"
- },
- {
- "ordinal": 6,
- "name": "updated_at",
- "type_info": "Timestamptz"
- },
- {
- "ordinal": 7,
- "name": "project_id?",
- "type_info": "Text"
- },
- {
- "ordinal": 8,
- "name": "sub_type?: DocumentSubType",
- "type_info": {
- "Custom": {
- "name": "document_sub_type_value",
- "kind": {
- "Enum": [
- "task",
- "snippet"
- ]
- }
- }
- }
- },
- {
- "ordinal": 9,
- "name": "is_completed",
- "type_info": "Bool"
- }
- ],
- "parameters": {
- "Left": [
- "Text",
- "Text",
- "Uuid"
- ]
- },
- "nullable": [
- false,
- false,
- false,
- null,
- true,
- null,
- null,
- true,
- false,
- null
- ]
- },
- "hash": "033759a1748c41359a8cf5204f457eed63182d21b432b58fd25b7524d1dc0092"
-}
diff --git a/.sqlx/query-03f16ea4b06173f2b99e11854680933e0bcdf6f1ba1afaa156e79937dbcb2124.json b/.sqlx/query-03f16ea4b06173f2b99e11854680933e0bcdf6f1ba1afaa156e79937dbcb2124.json
new file mode 100644
index 0000000000..a5bead8594
--- /dev/null
+++ b/.sqlx/query-03f16ea4b06173f2b99e11854680933e0bcdf6f1ba1afaa156e79937dbcb2124.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"ProjectPermission\" (\"projectId\", \"sharePermissionId\")\n VALUES ($1, $2)\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "03f16ea4b06173f2b99e11854680933e0bcdf6f1ba1afaa156e79937dbcb2124"
+}
diff --git a/.sqlx/query-7671b43028d90ea50536fbcd10ee0c1625c2e66de29cdf080f66832e62e07e76.json b/.sqlx/query-0aed6a0512b8eea223ea779ab439e8d52636ff0a61271cd918f98ef394dfc854.json
similarity index 51%
rename from .sqlx/query-7671b43028d90ea50536fbcd10ee0c1625c2e66de29cdf080f66832e62e07e76.json
rename to .sqlx/query-0aed6a0512b8eea223ea779ab439e8d52636ff0a61271cd918f98ef394dfc854.json
index 33c4519459..88da73dfb0 100644
--- a/.sqlx/query-7671b43028d90ea50536fbcd10ee0c1625c2e66de29cdf080f66832e62e07e76.json
+++ b/.sqlx/query-0aed6a0512b8eea223ea779ab439e8d52636ff0a61271cd918f98ef394dfc854.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n UPDATE \"Chat\" SET \"deletedAt\" = $2 WHERE id = ANY($1);\n ",
+ "query": "UPDATE \"Chat\" SET \"deletedAt\" = $2 WHERE id = ANY($1)",
"describe": {
"columns": [],
"parameters": {
@@ -11,5 +11,5 @@
},
"nullable": []
},
- "hash": "7671b43028d90ea50536fbcd10ee0c1625c2e66de29cdf080f66832e62e07e76"
+ "hash": "0aed6a0512b8eea223ea779ab439e8d52636ff0a61271cd918f98ef394dfc854"
}
diff --git a/.sqlx/query-0dd403bdd3475dfb010d5a725be35e76750719785a26e4c56e969fd48c5970b3.json b/.sqlx/query-0dd403bdd3475dfb010d5a725be35e76750719785a26e4c56e969fd48c5970b3.json
deleted file mode 100644
index 63fcd51931..0000000000
--- a/.sqlx/query-0dd403bdd3475dfb010d5a725be35e76750719785a26e4c56e969fd48c5970b3.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n WITH RECURSIVE project_hierarchy AS (\n SELECT\n p.id,\n p.\"userId\" as user_id\n FROM \"Project\" p\n WHERE p.id = $1 AND p.\"deletedAt\" IS NOT NULL\n UNION ALL\n SELECT\n sub_p.id,\n sub_p.\"userId\" as user_id\n FROM \"Project\" sub_p\n INNER JOIN project_hierarchy ph ON sub_p.\"parentId\" = ph.id\n WHERE sub_p.\"deletedAt\" IS NOT NULL\n )\n SELECT\n ph.id as \"id!\",\n ph.user_id as \"user_id!\"\n FROM project_hierarchy ph\n ",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "id!",
- "type_info": "Text"
- },
- {
- "ordinal": 1,
- "name": "user_id!",
- "type_info": "Text"
- }
- ],
- "parameters": {
- "Left": [
- "Text"
- ]
- },
- "nullable": [
- null,
- null
- ]
- },
- "hash": "0dd403bdd3475dfb010d5a725be35e76750719785a26e4c56e969fd48c5970b3"
-}
diff --git a/.sqlx/query-6b7094e2eaf150972507f937e120984ee4911e974d0bcc78248c022d44fa20f1.json b/.sqlx/query-0e925bf811ff9dbf234981b7a857a8e9fa3f87355affb3bfb0363b60461864cd.json
similarity index 55%
rename from .sqlx/query-6b7094e2eaf150972507f937e120984ee4911e974d0bcc78248c022d44fa20f1.json
rename to .sqlx/query-0e925bf811ff9dbf234981b7a857a8e9fa3f87355affb3bfb0363b60461864cd.json
index 396f195c48..eabf9c03a7 100644
--- a/.sqlx/query-6b7094e2eaf150972507f937e120984ee4911e974d0bcc78248c022d44fa20f1.json
+++ b/.sqlx/query-0e925bf811ff9dbf234981b7a857a8e9fa3f87355affb3bfb0363b60461864cd.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT \"sharePermissionId\" as id FROM \"ChatPermission\" WHERE \"chatId\" = ANY($1)\n ",
+ "query": "\n SELECT id\n FROM \"Chat\"\n WHERE \"projectId\" = ANY($1) AND \"deletedAt\" IS NOT NULL\n ",
"describe": {
"columns": [
{
@@ -18,5 +18,5 @@
false
]
},
- "hash": "6b7094e2eaf150972507f937e120984ee4911e974d0bcc78248c022d44fa20f1"
+ "hash": "0e925bf811ff9dbf234981b7a857a8e9fa3f87355affb3bfb0363b60461864cd"
}
diff --git a/.sqlx/query-3d0cc500bd9cee7fe4179b9ebc8176e5b20c478d2e5c4cba230e5fa3f57d38d6.json b/.sqlx/query-0fbead946cc1cb045e55f15e1c41975495a19cfc847196e4835c52afa602082a.json
similarity index 62%
rename from .sqlx/query-3d0cc500bd9cee7fe4179b9ebc8176e5b20c478d2e5c4cba230e5fa3f57d38d6.json
rename to .sqlx/query-0fbead946cc1cb045e55f15e1c41975495a19cfc847196e4835c52afa602082a.json
index 90d7d9ea68..f271ef5e8b 100644
--- a/.sqlx/query-3d0cc500bd9cee7fe4179b9ebc8176e5b20c478d2e5c4cba230e5fa3f57d38d6.json
+++ b/.sqlx/query-0fbead946cc1cb045e55f15e1c41975495a19cfc847196e4835c52afa602082a.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT\n p.id as id,\n p.name,\n p.\"userId\" as user_id,\n p.\"parentId\" as \"parent_id?\",\n p.\"createdAt\"::timestamptz as created_at,\n p.\"updatedAt\"::timestamptz as updated_at,\n p.\"deletedAt\"::timestamptz as deleted_at\n FROM\n \"Project\" p\n WHERE p.\"parentId\" = $1 AND p.\"deletedAt\" IS NULL\n ",
+ "query": "\n SELECT\n p.id,\n p.name,\n p.\"userId\" AS \"user_id\",\n p.\"parentId\" AS \"parent_id?\",\n p.\"createdAt\"::timestamptz AS \"created_at\",\n p.\"updatedAt\"::timestamptz AS \"updated_at\",\n p.\"deletedAt\"::timestamptz AS \"deleted_at\"\n FROM \"Project\" p\n WHERE p.\"parentId\" = $1 AND p.\"deletedAt\" IS NULL\n ORDER BY p.\"createdAt\" ASC, p.id ASC\n ",
"describe": {
"columns": [
{
@@ -54,5 +54,5 @@
null
]
},
- "hash": "3d0cc500bd9cee7fe4179b9ebc8176e5b20c478d2e5c4cba230e5fa3f57d38d6"
+ "hash": "0fbead946cc1cb045e55f15e1c41975495a19cfc847196e4835c52afa602082a"
}
diff --git a/.sqlx/query-7704391a443f1375ebd231197c4c21c7843eea381e396a3c688b390ced89620a.json b/.sqlx/query-14d04c75c6870eaee31d5ff6f64e4b8593f0bf6d5d6f97944283aead4d0431e2.json
similarity index 63%
rename from .sqlx/query-7704391a443f1375ebd231197c4c21c7843eea381e396a3c688b390ced89620a.json
rename to .sqlx/query-14d04c75c6870eaee31d5ff6f64e4b8593f0bf6d5d6f97944283aead4d0431e2.json
index e973ff399b..955907ac75 100644
--- a/.sqlx/query-7704391a443f1375ebd231197c4c21c7843eea381e396a3c688b390ced89620a.json
+++ b/.sqlx/query-14d04c75c6870eaee31d5ff6f64e4b8593f0bf6d5d6f97944283aead4d0431e2.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT\n c.id as id,\n c.name as name,\n c.\"userId\" as user_id,\n c.model as \"model?\",\n c.\"projectId\" as \"project_id?\",\n c.\"tokenCount\" as token_count,\n c.\"createdAt\"::timestamptz as created_at,\n c.\"updatedAt\"::timestamptz as updated_at,\n c.\"deletedAt\"::timestamptz as deleted_at,\n c.\"isPersistent\" as is_persistent\n FROM\n \"Chat\" c\n WHERE c.\"projectId\" = $1 AND c.\"deletedAt\" IS NULL\n ",
+ "query": "\n SELECT\n c.id,\n c.name,\n c.\"userId\" AS \"user_id\",\n c.model AS \"model?\",\n c.\"projectId\" AS \"project_id?\",\n c.\"tokenCount\" AS \"token_count\",\n c.\"createdAt\"::timestamptz AS \"created_at\",\n c.\"updatedAt\"::timestamptz AS \"updated_at\",\n c.\"deletedAt\"::timestamptz AS \"deleted_at\",\n c.\"isPersistent\" AS \"is_persistent\"\n FROM \"Chat\" c\n WHERE c.\"projectId\" = $1 AND c.\"deletedAt\" IS NULL\n ORDER BY c.\"createdAt\" ASC, c.id ASC\n ",
"describe": {
"columns": [
{
@@ -72,5 +72,5 @@
false
]
},
- "hash": "7704391a443f1375ebd231197c4c21c7843eea381e396a3c688b390ced89620a"
+ "hash": "14d04c75c6870eaee31d5ff6f64e4b8593f0bf6d5d6f97944283aead4d0431e2"
}
diff --git a/.sqlx/query-a1bf47e0cd99428ebbd99069e9ed4fdcdb3aaeb946ea3e5ca94dc58050ca7d97.json b/.sqlx/query-18873e86f757831adcdb60bb2c4071a06e3d06d4e2049a25f751146a5f010b13.json
similarity index 51%
rename from .sqlx/query-a1bf47e0cd99428ebbd99069e9ed4fdcdb3aaeb946ea3e5ca94dc58050ca7d97.json
rename to .sqlx/query-18873e86f757831adcdb60bb2c4071a06e3d06d4e2049a25f751146a5f010b13.json
index a20997623f..76f04d7e49 100644
--- a/.sqlx/query-a1bf47e0cd99428ebbd99069e9ed4fdcdb3aaeb946ea3e5ca94dc58050ca7d97.json
+++ b/.sqlx/query-18873e86f757831adcdb60bb2c4071a06e3d06d4e2049a25f751146a5f010b13.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n UPDATE \"Project\" SET \"deletedAt\" = $2 WHERE id = ANY($1);\n ",
+ "query": "UPDATE \"Document\" SET \"deletedAt\" = $2 WHERE id = ANY($1)",
"describe": {
"columns": [],
"parameters": {
@@ -11,5 +11,5 @@
},
"nullable": []
},
- "hash": "a1bf47e0cd99428ebbd99069e9ed4fdcdb3aaeb946ea3e5ca94dc58050ca7d97"
+ "hash": "18873e86f757831adcdb60bb2c4071a06e3d06d4e2049a25f751146a5f010b13"
}
diff --git a/.sqlx/query-1b9256d39a08d605aba08de1c5bddd8eb29bedd31dd21719114646449ab1333f.json b/.sqlx/query-1b9256d39a08d605aba08de1c5bddd8eb29bedd31dd21719114646449ab1333f.json
deleted file mode 100644
index d75fdd9537..0000000000
--- a/.sqlx/query-1b9256d39a08d605aba08de1c5bddd8eb29bedd31dd21719114646449ab1333f.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n WITH RECURSIVE project_hierarchy AS (\n SELECT\n p.id\n FROM \"Project\" p\n WHERE p.id = $1 AND p.\"deletedAt\" IS NULL\n UNION ALL\n SELECT\n sub_p.id\n FROM \"Project\" sub_p\n INNER JOIN project_hierarchy ph ON sub_p.\"parentId\" = ph.id\n WHERE sub_p.\"deletedAt\" IS NULL\n )\n SELECT\n ph.id as \"id!\"\n FROM project_hierarchy ph\n ",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "id!",
- "type_info": "Text"
- }
- ],
- "parameters": {
- "Left": [
- "Text"
- ]
- },
- "nullable": [
- null
- ]
- },
- "hash": "1b9256d39a08d605aba08de1c5bddd8eb29bedd31dd21719114646449ab1333f"
-}
diff --git a/.sqlx/query-1ee4ffd924167f7e5cda2be1ac66506c341547cd49c76e365129d91650474605.json b/.sqlx/query-1ee4ffd924167f7e5cda2be1ac66506c341547cd49c76e365129d91650474605.json
deleted file mode 100644
index cafa6efc60..0000000000
--- a/.sqlx/query-1ee4ffd924167f7e5cda2be1ac66506c341547cd49c76e365129d91650474605.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n INSERT INTO \"UserHistory\" (\"userId\", \"itemId\", \"itemType\", \"createdAt\", \"updatedAt\")\n SELECT u.user_id, u.item_id, 'document', NOW(), NOW()\n FROM UNNEST($1::text[], $2::text[]) AS u(item_id, user_id)\n ON CONFLICT (\"userId\", \"itemId\", \"itemType\") DO UPDATE\n SET \"updatedAt\" = NOW();\n ",
- "describe": {
- "columns": [],
- "parameters": {
- "Left": [
- "TextArray",
- "TextArray"
- ]
- },
- "nullable": []
- },
- "hash": "1ee4ffd924167f7e5cda2be1ac66506c341547cd49c76e365129d91650474605"
-}
diff --git a/.sqlx/query-25e274e230a97e15028f5fb5b2726e6bbfef04b96e4fa3e5bcdc541df4298486.json b/.sqlx/query-25e274e230a97e15028f5fb5b2726e6bbfef04b96e4fa3e5bcdc541df4298486.json
new file mode 100644
index 0000000000..17d8cb4f96
--- /dev/null
+++ b/.sqlx/query-25e274e230a97e15028f5fb5b2726e6bbfef04b96e4fa3e5bcdc541df4298486.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "DELETE FROM \"Pin\" WHERE \"pinnedItemId\" = ANY($1)",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "25e274e230a97e15028f5fb5b2726e6bbfef04b96e4fa3e5bcdc541df4298486"
+}
diff --git a/.sqlx/query-270e056bb1d522c9f46b8f8f0fde1d3307bf0627fe420be6bc0509072bae1565.json b/.sqlx/query-270e056bb1d522c9f46b8f8f0fde1d3307bf0627fe420be6bc0509072bae1565.json
deleted file mode 100644
index df429bfdc5..0000000000
--- a/.sqlx/query-270e056bb1d522c9f46b8f8f0fde1d3307bf0627fe420be6bc0509072bae1565.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n SELECT \"sharePermissionId\" as share_permission_id\n FROM \"ProjectPermission\"\n WHERE \"projectId\"=$1",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "share_permission_id",
- "type_info": "Text"
- }
- ],
- "parameters": {
- "Left": [
- "Text"
- ]
- },
- "nullable": [
- false
- ]
- },
- "hash": "270e056bb1d522c9f46b8f8f0fde1d3307bf0627fe420be6bc0509072bae1565"
-}
diff --git a/.sqlx/query-2b84c849315f16ff1a7cad87b2dc4a3a58d30376ad084f365f3764128a3b0c2b.json b/.sqlx/query-2b84c849315f16ff1a7cad87b2dc4a3a58d30376ad084f365f3764128a3b0c2b.json
new file mode 100644
index 0000000000..59afa5368c
--- /dev/null
+++ b/.sqlx/query-2b84c849315f16ff1a7cad87b2dc4a3a58d30376ad084f365f3764128a3b0c2b.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "UPDATE \"Document\" SET \"deletedAt\" = NULL WHERE id = ANY($1)",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "2b84c849315f16ff1a7cad87b2dc4a3a58d30376ad084f365f3764128a3b0c2b"
+}
diff --git a/.sqlx/query-2e5623dfbf4ecf94a1ba8080d1051e32faa99f49f106ed4050dcb38852eeb263.json b/.sqlx/query-2e5623dfbf4ecf94a1ba8080d1051e32faa99f49f106ed4050dcb38852eeb263.json
new file mode 100644
index 0000000000..78478f839a
--- /dev/null
+++ b/.sqlx/query-2e5623dfbf4ecf94a1ba8080d1051e32faa99f49f106ed4050dcb38852eeb263.json
@@ -0,0 +1,18 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n UPDATE \"SharePermission\"\n SET\n \"isPublic\" = CASE WHEN $2 THEN $3 ELSE \"isPublic\" END,\n \"publicAccessLevel\" = CASE WHEN $4 THEN $5 ELSE \"publicAccessLevel\" END,\n \"updatedAt\" = NOW()\n WHERE id = $1\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Bool",
+ "Bool",
+ "Bool",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "2e5623dfbf4ecf94a1ba8080d1051e32faa99f49f106ed4050dcb38852eeb263"
+}
diff --git a/.sqlx/query-2e946febc1bf52b183a3feeaf7eb151157e9a8eb105f468c57d79b98ee7a8088.json b/.sqlx/query-2e946febc1bf52b183a3feeaf7eb151157e9a8eb105f468c57d79b98ee7a8088.json
new file mode 100644
index 0000000000..9a855b41e2
--- /dev/null
+++ b/.sqlx/query-2e946febc1bf52b183a3feeaf7eb151157e9a8eb105f468c57d79b98ee7a8088.json
@@ -0,0 +1,34 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"DocumentBom\" (\"documentId\", \"createdAt\", \"updatedAt\")\n VALUES ($1, NOW(), NOW())\n RETURNING id, \"createdAt\"::timestamptz AS created_at, \"updatedAt\"::timestamptz AS updated_at\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Int8"
+ },
+ {
+ "ordinal": 1,
+ "name": "created_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 2,
+ "name": "updated_at",
+ "type_info": "Timestamptz"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ null,
+ null
+ ]
+ },
+ "hash": "2e946febc1bf52b183a3feeaf7eb151157e9a8eb105f468c57d79b98ee7a8088"
+}
diff --git a/.sqlx/query-31cd464c1db376661870318c9a85ce36c7a63c814300be48b770ca53fd042913.json b/.sqlx/query-31cd464c1db376661870318c9a85ce36c7a63c814300be48b770ca53fd042913.json
new file mode 100644
index 0000000000..18e237cf18
--- /dev/null
+++ b/.sqlx/query-31cd464c1db376661870318c9a85ce36c7a63c814300be48b770ca53fd042913.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "UPDATE \"Project\" SET \"deletedAt\" = NULL WHERE id = ANY($1)",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "31cd464c1db376661870318c9a85ce36c7a63c814300be48b770ca53fd042913"
+}
diff --git a/.sqlx/query-7f5d80a93c34a98c84c86f6dd678139fbab4c5bf559090a45d79384bcef71a43.json b/.sqlx/query-3359f22541c580890c7edeb19f8006bb75c8ba82b70fa836241251a497c470fd.json
similarity index 53%
rename from .sqlx/query-7f5d80a93c34a98c84c86f6dd678139fbab4c5bf559090a45d79384bcef71a43.json
rename to .sqlx/query-3359f22541c580890c7edeb19f8006bb75c8ba82b70fa836241251a497c470fd.json
index 699c743a02..5c6619278c 100644
--- a/.sqlx/query-7f5d80a93c34a98c84c86f6dd678139fbab4c5bf559090a45d79384bcef71a43.json
+++ b/.sqlx/query-3359f22541c580890c7edeb19f8006bb75c8ba82b70fa836241251a497c470fd.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n DELETE FROM \"Project\"\n WHERE id = $1",
+ "query": "UPDATE \"Project\" SET \"parentId\" = NULL WHERE id = $1",
"describe": {
"columns": [],
"parameters": {
@@ -10,5 +10,5 @@
},
"nullable": []
},
- "hash": "7f5d80a93c34a98c84c86f6dd678139fbab4c5bf559090a45d79384bcef71a43"
+ "hash": "3359f22541c580890c7edeb19f8006bb75c8ba82b70fa836241251a497c470fd"
}
diff --git a/.sqlx/query-33e0a69e797d9274f49771113b4abc47b8a9fe63263b050379d73cc14ce38fd7.json b/.sqlx/query-33e0a69e797d9274f49771113b4abc47b8a9fe63263b050379d73cc14ce38fd7.json
deleted file mode 100644
index ae0c6b9b23..0000000000
--- a/.sqlx/query-33e0a69e797d9274f49771113b4abc47b8a9fe63263b050379d73cc14ce38fd7.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n SELECT\n d.id\n FROM\n \"Document\" d\n WHERE\n d.\"projectId\" = ANY($1::text[])\n ",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "id",
- "type_info": "Text"
- }
- ],
- "parameters": {
- "Left": [
- "TextArray"
- ]
- },
- "nullable": [
- false
- ]
- },
- "hash": "33e0a69e797d9274f49771113b4abc47b8a9fe63263b050379d73cc14ce38fd7"
-}
diff --git a/.sqlx/query-350800132ce9026847f44354b415156432c57f20036d3e05eb8a72f09d88e10f.json b/.sqlx/query-350800132ce9026847f44354b415156432c57f20036d3e05eb8a72f09d88e10f.json
deleted file mode 100644
index 573f3269e8..0000000000
--- a/.sqlx/query-350800132ce9026847f44354b415156432c57f20036d3e05eb8a72f09d88e10f.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n INSERT INTO \"UserHistory\" (\"userId\", \"itemId\", \"itemType\", \"createdAt\", \"updatedAt\")\n SELECT u.user_id, u.item_id, 'project', NOW(), NOW()\n FROM UNNEST($1::text[], $2::text[]) AS u(item_id, user_id)\n ON CONFLICT (\"userId\", \"itemId\", \"itemType\") DO UPDATE\n SET \"updatedAt\" = NOW();\n ",
- "describe": {
- "columns": [],
- "parameters": {
- "Left": [
- "TextArray",
- "TextArray"
- ]
- },
- "nullable": []
- },
- "hash": "350800132ce9026847f44354b415156432c57f20036d3e05eb8a72f09d88e10f"
-}
diff --git a/.sqlx/query-3786782fd5772417722154eab72e8929a3e67f2f10d7e69c20da5b6b262286d6.json b/.sqlx/query-3786782fd5772417722154eab72e8929a3e67f2f10d7e69c20da5b6b262286d6.json
new file mode 100644
index 0000000000..103c08fe01
--- /dev/null
+++ b/.sqlx/query-3786782fd5772417722154eab72e8929a3e67f2f10d7e69c20da5b6b262286d6.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": "3786782fd5772417722154eab72e8929a3e67f2f10d7e69c20da5b6b262286d6"
+}
diff --git a/.sqlx/query-3e8d3378b4651a45d6e1cfee02d1d991bb8fa6a687207164d713487c524d87a6.json b/.sqlx/query-3e8d3378b4651a45d6e1cfee02d1d991bb8fa6a687207164d713487c524d87a6.json
deleted file mode 100644
index 6496703c4d..0000000000
--- a/.sqlx/query-3e8d3378b4651a45d6e1cfee02d1d991bb8fa6a687207164d713487c524d87a6.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n UPDATE \"Chat\" SET \"deletedAt\" = NULL WHERE id = ANY($1);\n ",
- "describe": {
- "columns": [],
- "parameters": {
- "Left": [
- "TextArray"
- ]
- },
- "nullable": []
- },
- "hash": "3e8d3378b4651a45d6e1cfee02d1d991bb8fa6a687207164d713487c524d87a6"
-}
diff --git a/.sqlx/query-42318865664a4515ec2200c22609b9fba237efce0385abde34d00725867fb58d.json b/.sqlx/query-42318865664a4515ec2200c22609b9fba237efce0385abde34d00725867fb58d.json
new file mode 100644
index 0000000000..3196261809
--- /dev/null
+++ b/.sqlx/query-42318865664a4515ec2200c22609b9fba237efce0385abde34d00725867fb58d.json
@@ -0,0 +1,16 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"ChannelSharePermission\" (share_permission_id, channel_id, access_level)\n VALUES ($1, $2, $3::text::\"AccessLevel\")\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "42318865664a4515ec2200c22609b9fba237efce0385abde34d00725867fb58d"
+}
diff --git a/.sqlx/query-42819bae543c0eab29e213ebc61c196f07bf9356dd64cae2fc168871ecd23353.json b/.sqlx/query-42819bae543c0eab29e213ebc61c196f07bf9356dd64cae2fc168871ecd23353.json
new file mode 100644
index 0000000000..2edec26da0
--- /dev/null
+++ b/.sqlx/query-42819bae543c0eab29e213ebc61c196f07bf9356dd64cae2fc168871ecd23353.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n WITH RECURSIVE project_hierarchy AS (\n SELECT id FROM \"Project\" WHERE id = $1 AND \"deletedAt\" IS NULL\n UNION ALL\n SELECT child.id\n FROM \"Project\" child\n JOIN project_hierarchy parent ON child.\"parentId\" = parent.id\n WHERE child.\"deletedAt\" IS NULL\n )\n SELECT id AS \"id!\" FROM project_hierarchy\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id!",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ null
+ ]
+ },
+ "hash": "42819bae543c0eab29e213ebc61c196f07bf9356dd64cae2fc168871ecd23353"
+}
diff --git a/.sqlx/query-43aedaff60665c1bf3dea9dc3e58908fd19aa1f6dd274803963698d6b95760ce.json b/.sqlx/query-43aedaff60665c1bf3dea9dc3e58908fd19aa1f6dd274803963698d6b95760ce.json
new file mode 100644
index 0000000000..2bef26ac3f
--- /dev/null
+++ b/.sqlx/query-43aedaff60665c1bf3dea9dc3e58908fd19aa1f6dd274803963698d6b95760ce.json
@@ -0,0 +1,88 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT\n d.id AS \"document_id\",\n d.owner,\n d.name AS \"document_name\",\n COALESCE(bom.id, instance.id) AS \"document_version_id!\",\n d.\"fileType\" AS \"file_type?\",\n d.\"createdAt\"::timestamptz AS \"created_at\",\n d.\"updatedAt\"::timestamptz AS \"updated_at\",\n d.\"projectId\" AS \"project_id?\",\n subtype.sub_type AS \"sub_type?: DocumentSubType\",\n CASE\n WHEN subtype.sub_type = 'task'\n AND status.values->'value' ? $2\n THEN true\n WHEN subtype.sub_type = 'task' THEN false\n ELSE NULL\n END AS \"is_completed\"\n FROM \"Document\" d\n LEFT JOIN document_sub_type subtype ON subtype.document_id = d.id\n LEFT JOIN entity_properties status\n ON subtype.sub_type = 'task'\n AND status.entity_id = d.id\n AND status.entity_type = 'TASK'\n AND status.property_definition_id = $3\n LEFT JOIN LATERAL (\n SELECT b.id\n FROM \"DocumentBom\" b\n WHERE b.\"documentId\" = d.id\n ORDER BY b.\"createdAt\" DESC\n LIMIT 1\n ) bom ON d.\"fileType\" = 'docx'\n LEFT JOIN LATERAL (\n SELECT i.id\n FROM \"DocumentInstance\" i\n WHERE i.\"documentId\" = d.id\n ORDER BY i.\"updatedAt\" DESC\n LIMIT 1\n ) instance ON d.\"fileType\" IS DISTINCT FROM 'docx'\n WHERE d.\"projectId\" = $1 AND d.\"deletedAt\" IS NULL\n ORDER BY d.\"createdAt\" ASC, d.id ASC\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "document_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "owner",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 2,
+ "name": "document_name",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 3,
+ "name": "document_version_id!",
+ "type_info": "Int8"
+ },
+ {
+ "ordinal": 4,
+ "name": "file_type?",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 5,
+ "name": "created_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 6,
+ "name": "updated_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 7,
+ "name": "project_id?",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 8,
+ "name": "sub_type?: DocumentSubType",
+ "type_info": {
+ "Custom": {
+ "name": "document_sub_type_value",
+ "kind": {
+ "Enum": [
+ "task",
+ "snippet"
+ ]
+ }
+ }
+ }
+ },
+ {
+ "ordinal": 9,
+ "name": "is_completed",
+ "type_info": "Bool"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text",
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false,
+ null,
+ true,
+ null,
+ null,
+ true,
+ false,
+ null
+ ]
+ },
+ "hash": "43aedaff60665c1bf3dea9dc3e58908fd19aa1f6dd274803963698d6b95760ce"
+}
diff --git a/.sqlx/query-00b50429eacf802503b639b2dc362bbdbf3d29b375b73ca25f7720941929f10b.json b/.sqlx/query-459f452f7069c7c587f0894fc7dca749b68d522255f51845cde57626dbaa3fa2.json
similarity index 52%
rename from .sqlx/query-00b50429eacf802503b639b2dc362bbdbf3d29b375b73ca25f7720941929f10b.json
rename to .sqlx/query-459f452f7069c7c587f0894fc7dca749b68d522255f51845cde57626dbaa3fa2.json
index 3cb6780373..d156706c2f 100644
--- a/.sqlx/query-00b50429eacf802503b639b2dc362bbdbf3d29b375b73ca25f7720941929f10b.json
+++ b/.sqlx/query-459f452f7069c7c587f0894fc7dca749b68d522255f51845cde57626dbaa3fa2.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n WITH RECURSIVE project_path AS (\n SELECT\n p.id,\n p.name,\n p.\"userId\",\n p.\"parentId\",\n p.\"updatedAt\",\n ARRAY[p.name] as path\n FROM \"Project\" p\n WHERE p.id = ANY($1)\n\n UNION ALL\n\n SELECT\n pp.id,\n pp.name,\n pp.\"userId\",\n parent.\"parentId\",\n pp.\"updatedAt\",\n ARRAY[parent.name] || pp.path as path\n FROM project_path pp\n JOIN \"Project\" parent ON pp.\"parentId\" = parent.id\n )\n SELECT DISTINCT ON (id)\n id as \"id!\",\n name as \"name!\",\n \"userId\" as \"owner!\",\n path as \"path!\",\n \"updatedAt\"::timestamptz as \"updated_at\"\n FROM project_path\n WHERE \"parentId\" IS NULL\n ORDER BY id\n ",
+ "query": "\n WITH RECURSIVE project_path AS (\n SELECT\n p.id,\n p.name,\n p.\"userId\",\n p.\"parentId\",\n p.\"updatedAt\",\n ARRAY[p.name] AS path\n FROM \"Project\" p\n WHERE p.id = ANY($1)\n\n UNION ALL\n\n SELECT\n child.id,\n child.name,\n child.\"userId\",\n parent.\"parentId\",\n child.\"updatedAt\",\n ARRAY[parent.name] || child.path AS path\n FROM project_path child\n JOIN \"Project\" parent ON child.\"parentId\" = parent.id\n )\n SELECT DISTINCT ON (id)\n id AS \"id!\",\n name AS \"name!\",\n \"userId\" AS \"owner!\",\n path AS \"path!\",\n \"updatedAt\"::timestamptz AS \"updated_at\"\n FROM project_path\n WHERE \"parentId\" IS NULL\n ORDER BY id\n ",
"describe": {
"columns": [
{
@@ -42,5 +42,5 @@
null
]
},
- "hash": "00b50429eacf802503b639b2dc362bbdbf3d29b375b73ca25f7720941929f10b"
+ "hash": "459f452f7069c7c587f0894fc7dca749b68d522255f51845cde57626dbaa3fa2"
}
diff --git a/.sqlx/query-467fc7bd79aaa296588af3527f1d1fa944740f01ce65798b18269b099a65a283.json b/.sqlx/query-467fc7bd79aaa296588af3527f1d1fa944740f01ce65798b18269b099a65a283.json
deleted file mode 100644
index f7c0d8d0b0..0000000000
--- a/.sqlx/query-467fc7bd79aaa296588af3527f1d1fa944740f01ce65798b18269b099a65a283.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n SELECT \"sharePermissionId\" as id FROM \"ProjectPermission\" WHERE \"projectId\" = ANY($1)\n ",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "id",
- "type_info": "Text"
- }
- ],
- "parameters": {
- "Left": [
- "TextArray"
- ]
- },
- "nullable": [
- false
- ]
- },
- "hash": "467fc7bd79aaa296588af3527f1d1fa944740f01ce65798b18269b099a65a283"
-}
diff --git a/.sqlx/query-50ac34f0a72f6b85588857a19bc9e88ee9feb8e2aed829d4d61926399e40d1a8.json b/.sqlx/query-50ac34f0a72f6b85588857a19bc9e88ee9feb8e2aed829d4d61926399e40d1a8.json
new file mode 100644
index 0000000000..4e2db8d429
--- /dev/null
+++ b/.sqlx/query-50ac34f0a72f6b85588857a19bc9e88ee9feb8e2aed829d4d61926399e40d1a8.json
@@ -0,0 +1,28 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT part.sha, COUNT(*) AS \"count!\"\n FROM \"BomPart\" part\n JOIN \"DocumentBom\" bom ON bom.id = part.\"documentBomId\"\n WHERE bom.\"documentId\" = ANY($1)\n GROUP BY part.sha\n ORDER BY part.sha\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "sha",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "count!",
+ "type_info": "Int8"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": [
+ false,
+ null
+ ]
+ },
+ "hash": "50ac34f0a72f6b85588857a19bc9e88ee9feb8e2aed829d4d61926399e40d1a8"
+}
diff --git a/.sqlx/query-56bc98d55555a5605ffe1fb098c61a56fe28b866c4e6684d4208f97a21a7c5d8.json b/.sqlx/query-56bc98d55555a5605ffe1fb098c61a56fe28b866c4e6684d4208f97a21a7c5d8.json
deleted file mode 100644
index c75072ce00..0000000000
--- a/.sqlx/query-56bc98d55555a5605ffe1fb098c61a56fe28b866c4e6684d4208f97a21a7c5d8.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n INSERT INTO \"UserHistory\" (\"userId\", \"itemId\", \"itemType\", \"createdAt\", \"updatedAt\")\n SELECT u.user_id, u.item_id, 'chat', NOW(), NOW()\n FROM UNNEST($1::text[], $2::text[]) AS u(item_id, user_id)\n ON CONFLICT (\"userId\", \"itemId\", \"itemType\") DO UPDATE\n SET \"updatedAt\" = NOW();\n ",
- "describe": {
- "columns": [],
- "parameters": {
- "Left": [
- "TextArray",
- "TextArray"
- ]
- },
- "nullable": []
- },
- "hash": "56bc98d55555a5605ffe1fb098c61a56fe28b866c4e6684d4208f97a21a7c5d8"
-}
diff --git a/.sqlx/query-598de0741ebf0429452f811608d8dd02537cc469db5154517f2f87d282dd40cc.json b/.sqlx/query-598de0741ebf0429452f811608d8dd02537cc469db5154517f2f87d282dd40cc.json
new file mode 100644
index 0000000000..3eccefe2ff
--- /dev/null
+++ b/.sqlx/query-598de0741ebf0429452f811608d8dd02537cc469db5154517f2f87d282dd40cc.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM entity_access\n WHERE entity_id::text = ANY($1)\n OR \"granted_from_project_id\" = ANY($2)\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray",
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "598de0741ebf0429452f811608d8dd02537cc469db5154517f2f87d282dd40cc"
+}
diff --git a/.sqlx/query-5bf68889b33f05bb6a3bf73a8c5f34506daace15fb818e5a591e179a90bb8c0e.json b/.sqlx/query-5bf68889b33f05bb6a3bf73a8c5f34506daace15fb818e5a591e179a90bb8c0e.json
new file mode 100644
index 0000000000..1a3eaf6507
--- /dev/null
+++ b/.sqlx/query-5bf68889b33f05bb6a3bf73a8c5f34506daace15fb818e5a591e179a90bb8c0e.json
@@ -0,0 +1,46 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT\n p.id,\n p.\"userId\" AS \"user_id\",\n p.name,\n p.\"parentId\" AS \"parent_id\",\n p.\"deletedAt\"::timestamptz AS \"deleted_at\"\n FROM \"Project\" p\n WHERE p.id = $1\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "user_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 2,
+ "name": "name",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 3,
+ "name": "parent_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 4,
+ "name": "deleted_at",
+ "type_info": "Timestamptz"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false,
+ true,
+ null
+ ]
+ },
+ "hash": "5bf68889b33f05bb6a3bf73a8c5f34506daace15fb818e5a591e179a90bb8c0e"
+}
diff --git a/.sqlx/query-3e3b2b04a9eb28ea82f8f97a2b725b205e0b6f330e4f3eb9690375e992ce2194.json b/.sqlx/query-6313733f77106a1838adbbe6e978b3c1bc4f48dc47815d940471d199e0f5c774.json
similarity index 61%
rename from .sqlx/query-3e3b2b04a9eb28ea82f8f97a2b725b205e0b6f330e4f3eb9690375e992ce2194.json
rename to .sqlx/query-6313733f77106a1838adbbe6e978b3c1bc4f48dc47815d940471d199e0f5c774.json
index dad50de6d8..6da8048fa2 100644
--- a/.sqlx/query-3e3b2b04a9eb28ea82f8f97a2b725b205e0b6f330e4f3eb9690375e992ce2194.json
+++ b/.sqlx/query-6313733f77106a1838adbbe6e978b3c1bc4f48dc47815d940471d199e0f5c774.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT \"id\" FROM \"Chat\" WHERE \"projectId\" = ANY($1)\n ",
+ "query": "SELECT id FROM \"Chat\" WHERE \"projectId\" = ANY($1)",
"describe": {
"columns": [
{
@@ -18,5 +18,5 @@
false
]
},
- "hash": "3e3b2b04a9eb28ea82f8f97a2b725b205e0b6f330e4f3eb9690375e992ce2194"
+ "hash": "6313733f77106a1838adbbe6e978b3c1bc4f48dc47815d940471d199e0f5c774"
}
diff --git a/.sqlx/query-70f12c0591fd0f66402ffc3720a5f5f7c6116cd761471bd5e03f528bf32effa5.json b/.sqlx/query-70f12c0591fd0f66402ffc3720a5f5f7c6116cd761471bd5e03f528bf32effa5.json
deleted file mode 100644
index 020d3dd88c..0000000000
--- a/.sqlx/query-70f12c0591fd0f66402ffc3720a5f5f7c6116cd761471bd5e03f528bf32effa5.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n SELECT \"sharePermissionId\" as id FROM \"DocumentPermission\" WHERE \"documentId\" = ANY($1)\n ",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "id",
- "type_info": "Text"
- }
- ],
- "parameters": {
- "Left": [
- "TextArray"
- ]
- },
- "nullable": [
- false
- ]
- },
- "hash": "70f12c0591fd0f66402ffc3720a5f5f7c6116cd761471bd5e03f528bf32effa5"
-}
diff --git a/.sqlx/query-72e22aae7c79ba68e9336f88c10920a55c4e1ed7b87a40c33f6b0c6fffd5b081.json b/.sqlx/query-72e22aae7c79ba68e9336f88c10920a55c4e1ed7b87a40c33f6b0c6fffd5b081.json
new file mode 100644
index 0000000000..c3d3e72646
--- /dev/null
+++ b/.sqlx/query-72e22aae7c79ba68e9336f88c10920a55c4e1ed7b87a40c33f6b0c6fffd5b081.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "DELETE FROM \"Document\" WHERE id = ANY($1)",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "72e22aae7c79ba68e9336f88c10920a55c4e1ed7b87a40c33f6b0c6fffd5b081"
+}
diff --git a/.sqlx/query-73e867afe203ae380c86b6b58b56e5381d69142d97f9eecbe800a64e945b6c63.json b/.sqlx/query-73e867afe203ae380c86b6b58b56e5381d69142d97f9eecbe800a64e945b6c63.json
new file mode 100644
index 0000000000..bee4696fc8
--- /dev/null
+++ b/.sqlx/query-73e867afe203ae380c86b6b58b56e5381d69142d97f9eecbe800a64e945b6c63.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n WITH RECURSIVE project_hierarchy AS (\n SELECT id FROM \"Project\" WHERE id = $1\n UNION ALL\n SELECT child.id\n FROM \"Project\" child\n JOIN project_hierarchy parent ON child.\"parentId\" = parent.id\n )\n UPDATE \"Project\"\n SET \"uploadPending\" = false\n WHERE id IN (SELECT id FROM project_hierarchy)\n RETURNING id\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "73e867afe203ae380c86b6b58b56e5381d69142d97f9eecbe800a64e945b6c63"
+}
diff --git a/.sqlx/query-77a3f1326c9f97c8e5f5995bdabd2915002b695b1736796160fff0b6d76f4b97.json b/.sqlx/query-77a3f1326c9f97c8e5f5995bdabd2915002b695b1736796160fff0b6d76f4b97.json
new file mode 100644
index 0000000000..f7fe996baa
--- /dev/null
+++ b/.sqlx/query-77a3f1326c9f97c8e5f5995bdabd2915002b695b1736796160fff0b6d76f4b97.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "DELETE FROM \"UserHistory\" WHERE \"itemId\" = ANY($1)",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "77a3f1326c9f97c8e5f5995bdabd2915002b695b1736796160fff0b6d76f4b97"
+}
diff --git a/.sqlx/query-7d2487e2e00482505b104e5386377e939dd85a9090b3d89d71bb495b2ba7cca9.json b/.sqlx/query-7d2487e2e00482505b104e5386377e939dd85a9090b3d89d71bb495b2ba7cca9.json
deleted file mode 100644
index 88476d02eb..0000000000
--- a/.sqlx/query-7d2487e2e00482505b104e5386377e939dd85a9090b3d89d71bb495b2ba7cca9.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n UPDATE \"Document\" SET \"deletedAt\" = NULL WHERE id = ANY($1);\n ",
- "describe": {
- "columns": [],
- "parameters": {
- "Left": [
- "TextArray"
- ]
- },
- "nullable": []
- },
- "hash": "7d2487e2e00482505b104e5386377e939dd85a9090b3d89d71bb495b2ba7cca9"
-}
diff --git a/.sqlx/query-3ff726c2ff64c69e2af5dca67815300efe7b0bcbd74ae96f3d65aeb8edd064f7.json b/.sqlx/query-80fbc24b20f3779fb5fa64c4aae380f6f8aaee7e41069f45d55f60270b792786.json
similarity index 67%
rename from .sqlx/query-3ff726c2ff64c69e2af5dca67815300efe7b0bcbd74ae96f3d65aeb8edd064f7.json
rename to .sqlx/query-80fbc24b20f3779fb5fa64c4aae380f6f8aaee7e41069f45d55f60270b792786.json
index 9cd2b5c5ae..ceb390e050 100644
--- a/.sqlx/query-3ff726c2ff64c69e2af5dca67815300efe7b0bcbd74ae96f3d65aeb8edd064f7.json
+++ b/.sqlx/query-80fbc24b20f3779fb5fa64c4aae380f6f8aaee7e41069f45d55f60270b792786.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT\n p.id,\n p.name,\n p.\"userId\" as user_id,\n p.\"parentId\" as parent_id,\n p.\"createdAt\"::timestamptz as created_at,\n p.\"updatedAt\"::timestamptz as updated_at,\n p.\"deletedAt\"::timestamptz as deleted_at\n FROM \"Project\" p\n WHERE id = $1 AND p.\"deletedAt\" IS NULL\n ",
+ "query": "\n SELECT\n p.id,\n p.name,\n p.\"userId\" AS \"user_id\",\n p.\"parentId\" AS \"parent_id\",\n p.\"createdAt\"::timestamptz AS \"created_at\",\n p.\"updatedAt\"::timestamptz AS \"updated_at\",\n p.\"deletedAt\"::timestamptz AS \"deleted_at\"\n FROM \"Project\" p\n WHERE p.id = $1 AND p.\"deletedAt\" IS NULL\n ",
"describe": {
"columns": [
{
@@ -54,5 +54,5 @@
null
]
},
- "hash": "3ff726c2ff64c69e2af5dca67815300efe7b0bcbd74ae96f3d65aeb8edd064f7"
+ "hash": "80fbc24b20f3779fb5fa64c4aae380f6f8aaee7e41069f45d55f60270b792786"
}
diff --git a/.sqlx/query-c0b0f58e6b2129250821f51fcb1ebe9d876c2e251f04f0aa9b1c0942d73a4e0d.json b/.sqlx/query-8293d118c38a99fcfbe14d597e38f12d92766a89f8677ac047a8e8c5ea31560b.json
similarity index 60%
rename from .sqlx/query-c0b0f58e6b2129250821f51fcb1ebe9d876c2e251f04f0aa9b1c0942d73a4e0d.json
rename to .sqlx/query-8293d118c38a99fcfbe14d597e38f12d92766a89f8677ac047a8e8c5ea31560b.json
index 658c35ffa3..ddeb9e1267 100644
--- a/.sqlx/query-c0b0f58e6b2129250821f51fcb1ebe9d876c2e251f04f0aa9b1c0942d73a4e0d.json
+++ b/.sqlx/query-8293d118c38a99fcfbe14d597e38f12d92766a89f8677ac047a8e8c5ea31560b.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT\n p.id,\n p.name,\n p.\"userId\" as user_id, -- createor of the project\n p.\"parentId\" as parent_id,\n p.\"createdAt\"::timestamptz as created_at,\n p.\"updatedAt\"::timestamptz as updated_at,\n p.\"deletedAt\"::timestamptz as deleted_at\n FROM \"UserHistory\" up\n INNER JOIN \"Project\" p ON up.\"itemId\" = p.id AND up.\"itemType\" = 'project'\n WHERE up.\"userId\" = $1 AND p.\"deletedAt\" IS NULL AND p.\"uploadPending\" = false\n ORDER BY p.\"updatedAt\" DESC\n ",
+ "query": "\n SELECT\n p.id,\n p.name,\n p.\"userId\" AS \"user_id\",\n p.\"parentId\" AS \"parent_id\",\n p.\"createdAt\"::timestamptz AS \"created_at\",\n p.\"updatedAt\"::timestamptz AS \"updated_at\",\n p.\"deletedAt\"::timestamptz AS \"deleted_at\"\n FROM \"UserHistory\" history\n INNER JOIN \"Project\" p\n ON history.\"itemId\" = p.id AND history.\"itemType\" = 'project'\n WHERE history.\"userId\" = $1\n AND p.\"deletedAt\" IS NULL\n AND p.\"uploadPending\" = false\n ORDER BY p.\"updatedAt\" DESC\n ",
"describe": {
"columns": [
{
@@ -54,5 +54,5 @@
null
]
},
- "hash": "c0b0f58e6b2129250821f51fcb1ebe9d876c2e251f04f0aa9b1c0942d73a4e0d"
+ "hash": "8293d118c38a99fcfbe14d597e38f12d92766a89f8677ac047a8e8c5ea31560b"
}
diff --git a/.sqlx/query-863819fa6b0c1e1c31726dc1633177507f07dd025e9632d4d99be597561bf0b4.json b/.sqlx/query-863819fa6b0c1e1c31726dc1633177507f07dd025e9632d4d99be597561bf0b4.json
new file mode 100644
index 0000000000..ebf25810a7
--- /dev/null
+++ b/.sqlx/query-863819fa6b0c1e1c31726dc1633177507f07dd025e9632d4d99be597561bf0b4.json
@@ -0,0 +1,61 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"Project\"\n (name, \"userId\", \"parentId\", \"createdAt\", \"updatedAt\", \"uploadPending\", \"uploadRequestId\")\n VALUES ($1, $2, $3, NOW(), NOW(), true, $4)\n RETURNING\n id,\n name,\n \"userId\" AS user_id,\n \"parentId\" AS parent_id,\n \"createdAt\"::timestamptz AS created_at,\n \"updatedAt\"::timestamptz AS updated_at,\n \"deletedAt\"::timestamptz AS deleted_at\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "name",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 2,
+ "name": "user_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 3,
+ "name": "parent_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 4,
+ "name": "created_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 5,
+ "name": "updated_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 6,
+ "name": "deleted_at",
+ "type_info": "Timestamptz"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false,
+ true,
+ null,
+ null,
+ null
+ ]
+ },
+ "hash": "863819fa6b0c1e1c31726dc1633177507f07dd025e9632d4d99be597561bf0b4"
+}
diff --git a/.sqlx/query-9218af6efad449ade5aad91bda03a734165e8a6dda47a0fa286bc0a80802b5cb.json b/.sqlx/query-9218af6efad449ade5aad91bda03a734165e8a6dda47a0fa286bc0a80802b5cb.json
new file mode 100644
index 0000000000..2e9dbcdbc7
--- /dev/null
+++ b/.sqlx/query-9218af6efad449ade5aad91bda03a734165e8a6dda47a0fa286bc0a80802b5cb.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "UPDATE \"Chat\" SET \"deletedAt\" = NULL WHERE id = ANY($1)",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "9218af6efad449ade5aad91bda03a734165e8a6dda47a0fa286bc0a80802b5cb"
+}
diff --git a/.sqlx/query-92dba2d5c70b9482250d50d4ba2fa193efba45a216538e6b17f74b3163f6ef51.json b/.sqlx/query-92dba2d5c70b9482250d50d4ba2fa193efba45a216538e6b17f74b3163f6ef51.json
new file mode 100644
index 0000000000..e7b702daac
--- /dev/null
+++ b/.sqlx/query-92dba2d5c70b9482250d50d4ba2fa193efba45a216538e6b17f74b3163f6ef51.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"UserHistory\" (\"userId\", \"itemId\", \"itemType\", \"createdAt\", \"updatedAt\")\n SELECT $1, id, 'document', NOW(), NOW() FROM UNNEST($2::text[]) AS id\n ON CONFLICT (\"userId\", \"itemId\", \"itemType\") DO UPDATE SET \"updatedAt\" = NOW()\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "92dba2d5c70b9482250d50d4ba2fa193efba45a216538e6b17f74b3163f6ef51"
+}
diff --git a/.sqlx/query-4be607458d6cc823fa5a692842b502b405bd0e971be8425d4573846beadb6bf3.json b/.sqlx/query-933dfce0a31e88e5aeefacfbc04301874e36cc9b22b07598ec907cd233b732d8.json
similarity index 62%
rename from .sqlx/query-4be607458d6cc823fa5a692842b502b405bd0e971be8425d4573846beadb6bf3.json
rename to .sqlx/query-933dfce0a31e88e5aeefacfbc04301874e36cc9b22b07598ec907cd233b732d8.json
index b502f33690..43a580906b 100644
--- a/.sqlx/query-4be607458d6cc823fa5a692842b502b405bd0e971be8425d4573846beadb6bf3.json
+++ b/.sqlx/query-933dfce0a31e88e5aeefacfbc04301874e36cc9b22b07598ec907cd233b732d8.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n INSERT INTO \"Project\" (\"name\", \"userId\", \"parentId\", \"createdAt\", \"updatedAt\", \"uploadPending\", \"uploadRequestId\")\n VALUES ($1, $2, $3, NOW(), NOW(), TRUE, $4)\n RETURNING id, name, \"userId\"::text as user_id, \"createdAt\"::timestamptz as created_at, \"deletedAt\"::timestamptz as deleted_at,\n \"updatedAt\"::timestamptz as updated_at, \"parentId\" as parent_id\n ",
+ "query": "\n INSERT INTO \"Project\" (name, \"userId\", \"parentId\", \"createdAt\", \"updatedAt\")\n VALUES ($1, $2, $3, NOW(), NOW())\n RETURNING\n id,\n name,\n \"userId\" AS user_id,\n \"parentId\" AS parent_id,\n \"createdAt\"::timestamptz AS created_at,\n \"updatedAt\"::timestamptz AS updated_at,\n \"deletedAt\"::timestamptz AS deleted_at\n ",
"describe": {
"columns": [
{
@@ -20,12 +20,12 @@
},
{
"ordinal": 3,
- "name": "created_at",
- "type_info": "Timestamptz"
+ "name": "parent_id",
+ "type_info": "Text"
},
{
"ordinal": 4,
- "name": "deleted_at",
+ "name": "created_at",
"type_info": "Timestamptz"
},
{
@@ -35,13 +35,12 @@
},
{
"ordinal": 6,
- "name": "parent_id",
- "type_info": "Text"
+ "name": "deleted_at",
+ "type_info": "Timestamptz"
}
],
"parameters": {
"Left": [
- "Text",
"Text",
"Text",
"Text"
@@ -51,11 +50,11 @@
false,
false,
false,
+ true,
null,
null,
- null,
- true
+ null
]
},
- "hash": "4be607458d6cc823fa5a692842b502b405bd0e971be8425d4573846beadb6bf3"
+ "hash": "933dfce0a31e88e5aeefacfbc04301874e36cc9b22b07598ec907cd233b732d8"
}
diff --git a/.sqlx/query-0da786be8ae29e36cd110a8875d838e3b6b8cf4bd6775d083867c733982545dd.json b/.sqlx/query-982c8a418e1b883942e3834dab248284e675746317976e608d388a769016428e.json
similarity index 51%
rename from .sqlx/query-0da786be8ae29e36cd110a8875d838e3b6b8cf4bd6775d083867c733982545dd.json
rename to .sqlx/query-982c8a418e1b883942e3834dab248284e675746317976e608d388a769016428e.json
index e635006372..5cddafdac5 100644
--- a/.sqlx/query-0da786be8ae29e36cd110a8875d838e3b6b8cf4bd6775d083867c733982545dd.json
+++ b/.sqlx/query-982c8a418e1b883942e3834dab248284e675746317976e608d388a769016428e.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n UPDATE \"Document\" SET \"deletedAt\" = $2 WHERE id = ANY($1);\n ",
+ "query": "UPDATE \"Project\" SET \"deletedAt\" = $2 WHERE id = ANY($1)",
"describe": {
"columns": [],
"parameters": {
@@ -11,5 +11,5 @@
},
"nullable": []
},
- "hash": "0da786be8ae29e36cd110a8875d838e3b6b8cf4bd6775d083867c733982545dd"
+ "hash": "982c8a418e1b883942e3834dab248284e675746317976e608d388a769016428e"
}
diff --git a/.sqlx/query-99b5ca2d049ead7ee900009e4b5ab6ef0354f4e8f87704d538e276ab55acb7f7.json b/.sqlx/query-99b5ca2d049ead7ee900009e4b5ab6ef0354f4e8f87704d538e276ab55acb7f7.json
new file mode 100644
index 0000000000..3f296573dc
--- /dev/null
+++ b/.sqlx/query-99b5ca2d049ead7ee900009e4b5ab6ef0354f4e8f87704d538e276ab55acb7f7.json
@@ -0,0 +1,28 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n WITH RECURSIVE project_hierarchy AS (\n SELECT id, \"userId\" AS user_id\n FROM \"Project\" WHERE id = $1 AND \"deletedAt\" IS NOT NULL\n UNION ALL\n SELECT child.id, child.\"userId\" AS user_id\n FROM \"Project\" child\n JOIN project_hierarchy parent ON child.\"parentId\" = parent.id\n WHERE child.\"deletedAt\" IS NOT NULL\n )\n SELECT id AS \"id!\", user_id AS \"user_id!\" FROM project_hierarchy\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id!",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "user_id!",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ null,
+ null
+ ]
+ },
+ "hash": "99b5ca2d049ead7ee900009e4b5ab6ef0354f4e8f87704d538e276ab55acb7f7"
+}
diff --git a/.sqlx/query-9b5f16d1d13c72cd3fe049e54cece5fcc0541a3d0ebcd11df94e092404e136f0.json b/.sqlx/query-9b5f16d1d13c72cd3fe049e54cece5fcc0541a3d0ebcd11df94e092404e136f0.json
new file mode 100644
index 0000000000..36f72515aa
--- /dev/null
+++ b/.sqlx/query-9b5f16d1d13c72cd3fe049e54cece5fcc0541a3d0ebcd11df94e092404e136f0.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "INSERT INTO \"DocumentPermission\" (\"documentId\", \"sharePermissionId\") VALUES ($1, $2)",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "9b5f16d1d13c72cd3fe049e54cece5fcc0541a3d0ebcd11df94e092404e136f0"
+}
diff --git a/.sqlx/query-a00bbf5266bbb1e49d7649bb8a613bc62d5dbdb4b84cff45a9446ac1e50cc0b6.json b/.sqlx/query-a00bbf5266bbb1e49d7649bb8a613bc62d5dbdb4b84cff45a9446ac1e50cc0b6.json
new file mode 100644
index 0000000000..909afd848e
--- /dev/null
+++ b/.sqlx/query-a00bbf5266bbb1e49d7649bb8a613bc62d5dbdb4b84cff45a9446ac1e50cc0b6.json
@@ -0,0 +1,35 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"DocumentInstance\" (\"documentId\", sha, \"createdAt\", \"updatedAt\")\n VALUES ($1, $2, NOW(), NOW())\n RETURNING id, \"createdAt\"::timestamptz AS created_at, \"updatedAt\"::timestamptz AS updated_at\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Int8"
+ },
+ {
+ "ordinal": 1,
+ "name": "created_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 2,
+ "name": "updated_at",
+ "type_info": "Timestamptz"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ null,
+ null
+ ]
+ },
+ "hash": "a00bbf5266bbb1e49d7649bb8a613bc62d5dbdb4b84cff45a9446ac1e50cc0b6"
+}
diff --git a/.sqlx/query-a3c8fa850c0126cd7c955c45aa6dca98b300e68308dc4421d64b15d4f5a3e4b7.json b/.sqlx/query-a3c8fa850c0126cd7c955c45aa6dca98b300e68308dc4421d64b15d4f5a3e4b7.json
new file mode 100644
index 0000000000..9d16b35909
--- /dev/null
+++ b/.sqlx/query-a3c8fa850c0126cd7c955c45aa6dca98b300e68308dc4421d64b15d4f5a3e4b7.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"UserHistory\" (\"userId\", \"itemId\", \"itemType\", \"createdAt\", \"updatedAt\")\n SELECT $1, id, 'project', NOW(), NOW() FROM UNNEST($2::text[]) AS id\n ON CONFLICT (\"userId\", \"itemId\", \"itemType\") DO UPDATE SET \"updatedAt\" = NOW()\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "a3c8fa850c0126cd7c955c45aa6dca98b300e68308dc4421d64b15d4f5a3e4b7"
+}
diff --git a/.sqlx/query-a75159efffeec8475ddc48e6694e25da119b3fcae60b91bc049f5b6754d0313f.json b/.sqlx/query-a75159efffeec8475ddc48e6694e25da119b3fcae60b91bc049f5b6754d0313f.json
new file mode 100644
index 0000000000..6c8f3932f5
--- /dev/null
+++ b/.sqlx/query-a75159efffeec8475ddc48e6694e25da119b3fcae60b91bc049f5b6754d0313f.json
@@ -0,0 +1,62 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n UPDATE \"Project\"\n SET\n name = CASE WHEN $2 THEN $3 ELSE name END,\n \"parentId\" = CASE WHEN $4 THEN $5 ELSE \"parentId\" END,\n \"updatedAt\" = NOW()\n WHERE id = $1\n RETURNING\n id,\n name,\n \"userId\" AS user_id,\n \"parentId\" AS parent_id,\n \"createdAt\"::timestamptz AS created_at,\n \"updatedAt\"::timestamptz AS updated_at,\n \"deletedAt\"::timestamptz AS deleted_at\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "name",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 2,
+ "name": "user_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 3,
+ "name": "parent_id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 4,
+ "name": "created_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 5,
+ "name": "updated_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 6,
+ "name": "deleted_at",
+ "type_info": "Timestamptz"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Bool",
+ "Text",
+ "Bool",
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ false,
+ true,
+ null,
+ null,
+ null
+ ]
+ },
+ "hash": "a75159efffeec8475ddc48e6694e25da119b3fcae60b91bc049f5b6754d0313f"
+}
diff --git a/.sqlx/query-a991a3a468c02f27709b7a45f27518c828b88bc4ca913019d9d4802395e7a22a.json b/.sqlx/query-a991a3a468c02f27709b7a45f27518c828b88bc4ca913019d9d4802395e7a22a.json
deleted file mode 100644
index 6c1bc17b21..0000000000
--- a/.sqlx/query-a991a3a468c02f27709b7a45f27518c828b88bc4ca913019d9d4802395e7a22a.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n UPDATE \"Project\" SET \"parentId\" = NULL WHERE \"id\" = $1\n ",
- "describe": {
- "columns": [],
- "parameters": {
- "Left": [
- "Text"
- ]
- },
- "nullable": []
- },
- "hash": "a991a3a468c02f27709b7a45f27518c828b88bc4ca913019d9d4802395e7a22a"
-}
diff --git a/.sqlx/query-fc9cc90bb37368b293d46d43efd16c178a9865c5926e4195249eb22e2a4a91b3.json b/.sqlx/query-aa6fe473019ca57efd0c5404bc92ad841a7a2c354d9fbed3aa60e27e33a3be43.json
similarity index 62%
rename from .sqlx/query-fc9cc90bb37368b293d46d43efd16c178a9865c5926e4195249eb22e2a4a91b3.json
rename to .sqlx/query-aa6fe473019ca57efd0c5404bc92ad841a7a2c354d9fbed3aa60e27e33a3be43.json
index fbcc874a9d..3b3357f175 100644
--- a/.sqlx/query-fc9cc90bb37368b293d46d43efd16c178a9865c5926e4195249eb22e2a4a91b3.json
+++ b/.sqlx/query-aa6fe473019ca57efd0c5404bc92ad841a7a2c354d9fbed3aa60e27e33a3be43.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT \"id\", \"userId\" as user_id FROM \"Chat\" WHERE \"projectId\" = ANY($1) AND \"deletedAt\" IS NOT NULL\n ",
+ "query": "\n SELECT id, \"userId\" AS user_id FROM \"Chat\"\n WHERE \"projectId\" = ANY($1) AND \"deletedAt\" IS NOT NULL\n ",
"describe": {
"columns": [
{
@@ -24,5 +24,5 @@
false
]
},
- "hash": "fc9cc90bb37368b293d46d43efd16c178a9865c5926e4195249eb22e2a4a91b3"
+ "hash": "aa6fe473019ca57efd0c5404bc92ad841a7a2c354d9fbed3aa60e27e33a3be43"
}
diff --git a/.sqlx/query-aba9d4ae626a82d5219ab748c66fc1d3e01d4af57af5d36325ab9c81ee04f993.json b/.sqlx/query-aba9d4ae626a82d5219ab748c66fc1d3e01d4af57af5d36325ab9c81ee04f993.json
new file mode 100644
index 0000000000..aa654d7ef4
--- /dev/null
+++ b/.sqlx/query-aba9d4ae626a82d5219ab748c66fc1d3e01d4af57af5d36325ab9c81ee04f993.json
@@ -0,0 +1,16 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"ChannelSharePermission\" (share_permission_id, channel_id, access_level)\n VALUES ($1, $2, $3::text::\"AccessLevel\")\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "aba9d4ae626a82d5219ab748c66fc1d3e01d4af57af5d36325ab9c81ee04f993"
+}
diff --git a/.sqlx/query-ad6ee6c6f66c0d64a7622a9c54ae88903607fc058ab856a8b1356f430878899d.json b/.sqlx/query-ad6ee6c6f66c0d64a7622a9c54ae88903607fc058ab856a8b1356f430878899d.json
new file mode 100644
index 0000000000..8aad30053f
--- /dev/null
+++ b/.sqlx/query-ad6ee6c6f66c0d64a7622a9c54ae88903607fc058ab856a8b1356f430878899d.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "SELECT \"sharePermissionId\" FROM \"ProjectPermission\" WHERE \"projectId\" = $1",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "sharePermissionId",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "ad6ee6c6f66c0d64a7622a9c54ae88903607fc058ab856a8b1356f430878899d"
+}
diff --git a/.sqlx/query-b451aa27d04bc44a6de314b50c9c7666b25c7ca3de87382cabdfb3d3076a3992.json b/.sqlx/query-b451aa27d04bc44a6de314b50c9c7666b25c7ca3de87382cabdfb3d3076a3992.json
new file mode 100644
index 0000000000..15b99652d0
--- /dev/null
+++ b/.sqlx/query-b451aa27d04bc44a6de314b50c9c7666b25c7ca3de87382cabdfb3d3076a3992.json
@@ -0,0 +1,16 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM \"SharePermission\"\n WHERE id IN (\n SELECT \"sharePermissionId\" FROM \"ProjectPermission\" WHERE \"projectId\" = ANY($1)\n UNION\n SELECT \"sharePermissionId\" FROM \"DocumentPermission\" WHERE \"documentId\" = ANY($2)\n UNION\n SELECT \"sharePermissionId\" FROM \"ChatPermission\" WHERE \"chatId\" = ANY($3)\n )\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray",
+ "TextArray",
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "b451aa27d04bc44a6de314b50c9c7666b25c7ca3de87382cabdfb3d3076a3992"
+}
diff --git a/.sqlx/query-bbdb96688fe6edb340cbb6b0beab958f78b356243700e9d0fd142bf29a46b493.json b/.sqlx/query-bbdb96688fe6edb340cbb6b0beab958f78b356243700e9d0fd142bf29a46b493.json
new file mode 100644
index 0000000000..2ad2e52f8d
--- /dev/null
+++ b/.sqlx/query-bbdb96688fe6edb340cbb6b0beab958f78b356243700e9d0fd142bf29a46b493.json
@@ -0,0 +1,28 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT id, owner\n FROM \"Document\"\n WHERE \"projectId\" = ANY($1) AND \"deletedAt\" IS NOT NULL\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "owner",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": [
+ false,
+ false
+ ]
+ },
+ "hash": "bbdb96688fe6edb340cbb6b0beab958f78b356243700e9d0fd142bf29a46b493"
+}
diff --git a/.sqlx/query-bf98ad9ab317aeb662ab9859a9a076ba4cb25186e0743845a7bb0fc5db1f4c99.json b/.sqlx/query-bf98ad9ab317aeb662ab9859a9a076ba4cb25186e0743845a7bb0fc5db1f4c99.json
new file mode 100644
index 0000000000..cf1488533f
--- /dev/null
+++ b/.sqlx/query-bf98ad9ab317aeb662ab9859a9a076ba4cb25186e0743845a7bb0fc5db1f4c99.json
@@ -0,0 +1,46 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT\n permission.id,\n permission.\"isPublic\" AS \"is_public\",\n permission.\"publicAccessLevel\" AS \"public_access_level?\",\n project.\"userId\" AS owner,\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 \"ProjectPermission\" project_permission\n JOIN \"SharePermission\" permission\n ON project_permission.\"sharePermissionId\" = permission.id\n JOIN \"Project\" project ON project_permission.\"projectId\" = project.id\n LEFT JOIN \"ChannelSharePermission\" channel\n ON channel.\"share_permission_id\" = permission.id\n WHERE project_permission.\"projectId\" = $1\n GROUP BY permission.id, project.\"userId\"\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "is_public",
+ "type_info": "Bool"
+ },
+ {
+ "ordinal": 2,
+ "name": "public_access_level?",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 3,
+ "name": "owner",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 4,
+ "name": "channel_share_permissions?",
+ "type_info": "Json"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ false,
+ true,
+ false,
+ null
+ ]
+ },
+ "hash": "bf98ad9ab317aeb662ab9859a9a076ba4cb25186e0743845a7bb0fc5db1f4c99"
+}
diff --git a/.sqlx/query-c506ec0bcb09c340837dcb93ef123fc165b49fb8b1cea697e9bbd198f61e00a9.json b/.sqlx/query-c506ec0bcb09c340837dcb93ef123fc165b49fb8b1cea697e9bbd198f61e00a9.json
new file mode 100644
index 0000000000..fc1b50c097
--- /dev/null
+++ b/.sqlx/query-c506ec0bcb09c340837dcb93ef123fc165b49fb8b1cea697e9bbd198f61e00a9.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "DELETE FROM \"Chat\" WHERE id = ANY($1)",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "c506ec0bcb09c340837dcb93ef123fc165b49fb8b1cea697e9bbd198f61e00a9"
+}
diff --git a/.sqlx/query-c56a4fa16649606f0b9e2af23270eafcc09a741455c4845cc0004408f272031a.json b/.sqlx/query-c56a4fa16649606f0b9e2af23270eafcc09a741455c4845cc0004408f272031a.json
new file mode 100644
index 0000000000..f78dc1e752
--- /dev/null
+++ b/.sqlx/query-c56a4fa16649606f0b9e2af23270eafcc09a741455c4845cc0004408f272031a.json
@@ -0,0 +1,23 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n WITH RECURSIVE descendants AS (\n SELECT id FROM \"Project\" WHERE \"parentId\" = $1 AND \"deletedAt\" IS NULL\n UNION ALL\n SELECT child.id\n FROM \"Project\" child\n JOIN descendants parent ON child.\"parentId\" = parent.id\n WHERE child.\"deletedAt\" IS NULL\n )\n SELECT ($1 = $2) OR EXISTS(SELECT 1 FROM descendants WHERE id = $2) AS \"exists!\"\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "exists!",
+ "type_info": "Bool"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": [
+ null
+ ]
+ },
+ "hash": "c56a4fa16649606f0b9e2af23270eafcc09a741455c4845cc0004408f272031a"
+}
diff --git a/.sqlx/query-c634aea246eb5a1004df4f7abf53bed966750e3a9609e5fbe79a4fbc18495efd.json b/.sqlx/query-c634aea246eb5a1004df4f7abf53bed966750e3a9609e5fbe79a4fbc18495efd.json
new file mode 100644
index 0000000000..7961f36148
--- /dev/null
+++ b/.sqlx/query-c634aea246eb5a1004df4f7abf53bed966750e3a9609e5fbe79a4fbc18495efd.json
@@ -0,0 +1,16 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"UserHistory\" (\"userId\", \"itemId\", \"itemType\", \"createdAt\", \"updatedAt\")\n SELECT value.owner_id, value.item_id, $3, NOW(), NOW()\n FROM UNNEST($1::text[], $2::text[]) AS value(item_id, owner_id)\n ON CONFLICT (\"userId\", \"itemId\", \"itemType\") DO UPDATE\n SET \"updatedAt\" = NOW()\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray",
+ "TextArray",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "c634aea246eb5a1004df4f7abf53bed966750e3a9609e5fbe79a4fbc18495efd"
+}
diff --git a/.sqlx/query-c8c1aa74fe9fce6bcfdc0f077d27e2ff935132e596271f15541e3d1e0ed0e53e.json b/.sqlx/query-c8c1aa74fe9fce6bcfdc0f077d27e2ff935132e596271f15541e3d1e0ed0e53e.json
new file mode 100644
index 0000000000..92916e91cb
--- /dev/null
+++ b/.sqlx/query-c8c1aa74fe9fce6bcfdc0f077d27e2ff935132e596271f15541e3d1e0ed0e53e.json
@@ -0,0 +1,37 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"Document\" (owner, name, \"fileType\", \"projectId\", \"createdAt\", \"updatedAt\")\n VALUES ($1, $2, $3, $4, NOW(), NOW())\n RETURNING id, \"createdAt\"::timestamptz AS created_at, \"updatedAt\"::timestamptz AS updated_at\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "created_at",
+ "type_info": "Timestamptz"
+ },
+ {
+ "ordinal": 2,
+ "name": "updated_at",
+ "type_info": "Timestamptz"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text",
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": [
+ false,
+ null,
+ null
+ ]
+ },
+ "hash": "c8c1aa74fe9fce6bcfdc0f077d27e2ff935132e596271f15541e3d1e0ed0e53e"
+}
diff --git a/.sqlx/query-c8f34fe33771813859b548d69d19f4b4d0b1b972d34c935de0919fbda84cce6c.json b/.sqlx/query-c8f34fe33771813859b548d69d19f4b4d0b1b972d34c935de0919fbda84cce6c.json
new file mode 100644
index 0000000000..17ee804dd9
--- /dev/null
+++ b/.sqlx/query-c8f34fe33771813859b548d69d19f4b4d0b1b972d34c935de0919fbda84cce6c.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n INSERT INTO \"UserHistory\" (\"userId\", \"itemId\", \"itemType\", \"createdAt\", \"updatedAt\")\n VALUES ($1, $2, 'project', NOW(), NOW())\n ON CONFLICT (\"userId\", \"itemId\", \"itemType\") DO UPDATE\n SET \"updatedAt\" = NOW()\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "c8f34fe33771813859b548d69d19f4b4d0b1b972d34c935de0919fbda84cce6c"
+}
diff --git a/.sqlx/query-d302e6d7eb19a6e1af488d4baf2ecbf5c65fe7dd1c916810c7bd85672af86b4c.json b/.sqlx/query-d302e6d7eb19a6e1af488d4baf2ecbf5c65fe7dd1c916810c7bd85672af86b4c.json
new file mode 100644
index 0000000000..013b8f897b
--- /dev/null
+++ b/.sqlx/query-d302e6d7eb19a6e1af488d4baf2ecbf5c65fe7dd1c916810c7bd85672af86b4c.json
@@ -0,0 +1,15 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n DELETE FROM \"ChannelSharePermission\"\n WHERE share_permission_id = $1 AND channel_id = $2\n ",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "Text",
+ "Text"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "d302e6d7eb19a6e1af488d4baf2ecbf5c65fe7dd1c916810c7bd85672af86b4c"
+}
diff --git a/.sqlx/query-11a723b710519837eb7643af73af6526dfa6bf93465f9c6708dc95e8237c1f51.json b/.sqlx/query-d5c3283be4274573b38b4a0e87c6b3c82e50546d6b7f570c11a4ee546700853f.json
similarity index 61%
rename from .sqlx/query-11a723b710519837eb7643af73af6526dfa6bf93465f9c6708dc95e8237c1f51.json
rename to .sqlx/query-d5c3283be4274573b38b4a0e87c6b3c82e50546d6b7f570c11a4ee546700853f.json
index ce42810756..08ccda0406 100644
--- a/.sqlx/query-11a723b710519837eb7643af73af6526dfa6bf93465f9c6708dc95e8237c1f51.json
+++ b/.sqlx/query-d5c3283be4274573b38b4a0e87c6b3c82e50546d6b7f570c11a4ee546700853f.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT \"id\" FROM \"Document\" WHERE \"projectId\" = ANY($1)\n ",
+ "query": "SELECT id FROM \"Document\" WHERE \"projectId\" = ANY($1)",
"describe": {
"columns": [
{
@@ -18,5 +18,5 @@
false
]
},
- "hash": "11a723b710519837eb7643af73af6526dfa6bf93465f9c6708dc95e8237c1f51"
+ "hash": "d5c3283be4274573b38b4a0e87c6b3c82e50546d6b7f570c11a4ee546700853f"
}
diff --git a/.sqlx/query-df4f91b8a401ff941c7b57f910979e0ec39a507de612ff7887172062237f29ce.json b/.sqlx/query-df4f91b8a401ff941c7b57f910979e0ec39a507de612ff7887172062237f29ce.json
deleted file mode 100644
index 9f8f5e53d4..0000000000
--- a/.sqlx/query-df4f91b8a401ff941c7b57f910979e0ec39a507de612ff7887172062237f29ce.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n UPDATE \"Project\" SET \"deletedAt\" = NULL WHERE id = ANY($1);\n ",
- "describe": {
- "columns": [],
- "parameters": {
- "Left": [
- "TextArray"
- ]
- },
- "nullable": []
- },
- "hash": "df4f91b8a401ff941c7b57f910979e0ec39a507de612ff7887172062237f29ce"
-}
diff --git a/.sqlx/query-dfccb13f0d0abe2be31bb40067f2e4c29fe260e81d13c017b8bc4fae2b94703f.json b/.sqlx/query-dfccb13f0d0abe2be31bb40067f2e4c29fe260e81d13c017b8bc4fae2b94703f.json
deleted file mode 100644
index e646e8765d..0000000000
--- a/.sqlx/query-dfccb13f0d0abe2be31bb40067f2e4c29fe260e81d13c017b8bc4fae2b94703f.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n UPDATE \"Project\"\n SET \"uploadPending\" = false\n WHERE id = ANY($1)\n RETURNING id\n ",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "id",
- "type_info": "Text"
- }
- ],
- "parameters": {
- "Left": [
- "TextArray"
- ]
- },
- "nullable": [
- false
- ]
- },
- "hash": "dfccb13f0d0abe2be31bb40067f2e4c29fe260e81d13c017b8bc4fae2b94703f"
-}
diff --git a/.sqlx/query-e33fa0c9cec501d3d4a9c98d1c80717756b395ffb54f82d50691520065eb6036.json b/.sqlx/query-e33fa0c9cec501d3d4a9c98d1c80717756b395ffb54f82d50691520065eb6036.json
deleted file mode 100644
index 057a1963fc..0000000000
--- a/.sqlx/query-e33fa0c9cec501d3d4a9c98d1c80717756b395ffb54f82d50691520065eb6036.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n DELETE FROM \"Pin\" WHERE \"pinnedItemId\" = ANY($1)\n ",
- "describe": {
- "columns": [],
- "parameters": {
- "Left": [
- "TextArray"
- ]
- },
- "nullable": []
- },
- "hash": "e33fa0c9cec501d3d4a9c98d1c80717756b395ffb54f82d50691520065eb6036"
-}
diff --git a/.sqlx/query-e5f72cb1e140a0044783b2c329e3160a78c82e5d4b56aa66785582da3aa905b7.json b/.sqlx/query-e5f72cb1e140a0044783b2c329e3160a78c82e5d4b56aa66785582da3aa905b7.json
new file mode 100644
index 0000000000..6ef0e3759c
--- /dev/null
+++ b/.sqlx/query-e5f72cb1e140a0044783b2c329e3160a78c82e5d4b56aa66785582da3aa905b7.json
@@ -0,0 +1,14 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "DELETE FROM \"Project\" WHERE id = ANY($1)",
+ "describe": {
+ "columns": [],
+ "parameters": {
+ "Left": [
+ "TextArray"
+ ]
+ },
+ "nullable": []
+ },
+ "hash": "e5f72cb1e140a0044783b2c329e3160a78c82e5d4b56aa66785582da3aa905b7"
+}
diff --git a/.sqlx/query-980f95d4b95f6a981b86bdbdda30b4b5ee7ee34505f206d0a6861cec41ef589a.json b/.sqlx/query-e6f54d0c4d83082c35620286bb6cb1d064870430b1cfa543cf2532e251205058.json
similarity index 60%
rename from .sqlx/query-980f95d4b95f6a981b86bdbdda30b4b5ee7ee34505f206d0a6861cec41ef589a.json
rename to .sqlx/query-e6f54d0c4d83082c35620286bb6cb1d064870430b1cfa543cf2532e251205058.json
index 4145c5fb82..0eeda279ff 100644
--- a/.sqlx/query-980f95d4b95f6a981b86bdbdda30b4b5ee7ee34505f206d0a6861cec41ef589a.json
+++ b/.sqlx/query-e6f54d0c4d83082c35620286bb6cb1d064870430b1cfa543cf2532e251205058.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT\n p.id,\n p.name,\n p.\"userId\" as user_id,\n p.\"parentId\" as parent_id,\n p.\"createdAt\"::timestamptz as created_at,\n p.\"updatedAt\"::timestamptz as updated_at,\n p.\"uploadRequestId\" as upload_request_id\n FROM \"Project\" p\n WHERE p.\"userId\" = $1 AND p.\"deletedAt\" IS NULL AND p.\"uploadPending\" = true AND p.\"parentId\" IS NULL\n ORDER BY p.\"updatedAt\" DESC\n ",
+ "query": "\n SELECT\n p.id,\n p.name,\n p.\"userId\" AS \"user_id\",\n p.\"parentId\" AS \"parent_id\",\n p.\"createdAt\"::timestamptz AS \"created_at\",\n p.\"updatedAt\"::timestamptz AS \"updated_at\",\n p.\"uploadRequestId\" AS \"upload_request_id\"\n FROM \"Project\" p\n WHERE p.\"userId\" = $1\n AND p.\"deletedAt\" IS NULL\n AND p.\"uploadPending\" = true\n AND p.\"parentId\" IS NULL\n ORDER BY p.\"updatedAt\" DESC\n ",
"describe": {
"columns": [
{
@@ -54,5 +54,5 @@
true
]
},
- "hash": "980f95d4b95f6a981b86bdbdda30b4b5ee7ee34505f206d0a6861cec41ef589a"
+ "hash": "e6f54d0c4d83082c35620286bb6cb1d064870430b1cfa543cf2532e251205058"
}
diff --git a/.sqlx/query-9d8ebf3f5901badeacb46837f0a2222f49274e9e72dbd25cf9c197b4f97654a5.json b/.sqlx/query-ec742212dfe9641ff0120ba4a4870b6938f508d29ac1e5eb71b75717331f54d1.json
similarity index 63%
rename from .sqlx/query-9d8ebf3f5901badeacb46837f0a2222f49274e9e72dbd25cf9c197b4f97654a5.json
rename to .sqlx/query-ec742212dfe9641ff0120ba4a4870b6938f508d29ac1e5eb71b75717331f54d1.json
index 05f7b62da7..63d638a077 100644
--- a/.sqlx/query-9d8ebf3f5901badeacb46837f0a2222f49274e9e72dbd25cf9c197b4f97654a5.json
+++ b/.sqlx/query-ec742212dfe9641ff0120ba4a4870b6938f508d29ac1e5eb71b75717331f54d1.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT id, owner FROM \"Document\" WHERE \"projectId\" = ANY($1) AND \"deletedAt\" IS NOT NULL\n ",
+ "query": "\n SELECT id, owner FROM \"Document\"\n WHERE \"projectId\" = ANY($1) AND \"deletedAt\" IS NOT NULL\n ",
"describe": {
"columns": [
{
@@ -24,5 +24,5 @@
false
]
},
- "hash": "9d8ebf3f5901badeacb46837f0a2222f49274e9e72dbd25cf9c197b4f97654a5"
+ "hash": "ec742212dfe9641ff0120ba4a4870b6938f508d29ac1e5eb71b75717331f54d1"
}
diff --git a/.sqlx/query-f4acb15153e914588ba0aeebcdad3d47804bda301d53441f8ccfb2ff3a271f11.json b/.sqlx/query-f4acb15153e914588ba0aeebcdad3d47804bda301d53441f8ccfb2ff3a271f11.json
new file mode 100644
index 0000000000..301357ead3
--- /dev/null
+++ b/.sqlx/query-f4acb15153e914588ba0aeebcdad3d47804bda301d53441f8ccfb2ff3a271f11.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n WITH RECURSIVE project_hierarchy AS (\n SELECT id\n FROM \"Project\"\n WHERE id = $1 AND \"deletedAt\" IS NOT NULL\n UNION ALL\n SELECT child.id\n FROM \"Project\" child\n JOIN project_hierarchy parent ON child.\"parentId\" = parent.id\n WHERE child.\"deletedAt\" IS NOT NULL\n )\n SELECT id AS \"id!\" FROM project_hierarchy\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "id!",
+ "type_info": "Text"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ null
+ ]
+ },
+ "hash": "f4acb15153e914588ba0aeebcdad3d47804bda301d53441f8ccfb2ff3a271f11"
+}
diff --git a/.sqlx/query-f6c0addc618fb161405a1a989f2cacd0718c070eb2ee345d524abe7ba8b5b35e.json b/.sqlx/query-f6c0addc618fb161405a1a989f2cacd0718c070eb2ee345d524abe7ba8b5b35e.json
deleted file mode 100644
index 0d013147f7..0000000000
--- a/.sqlx/query-f6c0addc618fb161405a1a989f2cacd0718c070eb2ee345d524abe7ba8b5b35e.json
+++ /dev/null
@@ -1,46 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n SELECT\n sp.id as id,\n sp.\"isPublic\" as is_public,\n sp.\"publicAccessLevel\" as \"public_access_level?\",\n p.\"userId\" as owner,\n COALESCE(\n json_agg(json_build_object(\n 'channel_id', csp.\"channel_id\",\n 'access_level', csp.\"access_level\"\n )) FILTER (WHERE csp.\"channel_id\" IS NOT NULL),\n '[]'\n ) as \"channel_share_permissions?\"\n FROM\n \"ProjectPermission\" pp\n JOIN \"SharePermission\" sp ON pp.\"sharePermissionId\" = sp.id\n JOIN \"Project\" p ON pp.\"projectId\" = p.id\n LEFT JOIN \"ChannelSharePermission\" csp ON csp.\"share_permission_id\" = sp.id\n WHERE\n pp.\"projectId\" = $1\n GROUP BY\n sp.id, p.\"userId\"\n ",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "id",
- "type_info": "Text"
- },
- {
- "ordinal": 1,
- "name": "is_public",
- "type_info": "Bool"
- },
- {
- "ordinal": 2,
- "name": "public_access_level?",
- "type_info": "Text"
- },
- {
- "ordinal": 3,
- "name": "owner",
- "type_info": "Text"
- },
- {
- "ordinal": 4,
- "name": "channel_share_permissions?",
- "type_info": "Json"
- }
- ],
- "parameters": {
- "Left": [
- "Text"
- ]
- },
- "nullable": [
- false,
- false,
- true,
- false,
- null
- ]
- },
- "hash": "f6c0addc618fb161405a1a989f2cacd0718c070eb2ee345d524abe7ba8b5b35e"
-}
diff --git a/.sqlx/query-fdf78a4ba9ee91c313df47c69338e6c0bb89189dda9e941393173d5763cbcedc.json b/.sqlx/query-fdf78a4ba9ee91c313df47c69338e6c0bb89189dda9e941393173d5763cbcedc.json
new file mode 100644
index 0000000000..e35836e13c
--- /dev/null
+++ b/.sqlx/query-fdf78a4ba9ee91c313df47c69338e6c0bb89189dda9e941393173d5763cbcedc.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "SELECT \"deletedAt\" IS NOT NULL AS \"is_deleted!\" FROM \"Project\" WHERE id = $1",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "is_deleted!",
+ "type_info": "Bool"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Text"
+ ]
+ },
+ "nullable": [
+ null
+ ]
+ },
+ "hash": "fdf78a4ba9ee91c313df47c69338e6c0bb89189dda9e941393173d5763cbcedc"
+}
diff --git a/Cargo.lock b/Cargo.lock
index 1459d4c1da..cb847efda5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4250,7 +4250,6 @@ dependencies = [
"macro_env_var",
"macro_event_broker",
"macro_middleware",
- "macro_project_utils",
"macro_queues",
"macro_service_urls",
"macro_sha_count_client",
@@ -4273,6 +4272,7 @@ dependencies = [
"notification",
"opensearch_client",
"ordered-float",
+ "projects",
"properties",
"properties_service",
"rate_limit",
@@ -8391,18 +8391,6 @@ dependencies = [
"workspace-hack",
]
-[[package]]
-name = "macro_project_utils"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "sqlx",
- "sqs_client",
- "tokio",
- "tracing",
- "workspace-hack",
-]
-
[[package]]
name = "macro_queues"
version = "0.1.0"
@@ -11004,6 +10992,58 @@ dependencies = [
"syn 2.0.117",
]
+[[package]]
+name = "projects"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-recursion",
+ "aws-sdk-s3",
+ "axum",
+ "axum-extra",
+ "base64 0.22.1",
+ "chrono",
+ "document_sub_type",
+ "dotenvy",
+ "dynamodb_client",
+ "entity_access",
+ "entity_access_db_utils",
+ "entity_access_management",
+ "futures",
+ "hex",
+ "http-body-util",
+ "macro_authorization",
+ "macro_aws_config",
+ "macro_db_migrator",
+ "macro_env",
+ "macro_env_var",
+ "macro_sha_count_client",
+ "macro_user_id",
+ "macro_uuid",
+ "mockall",
+ "model",
+ "model-entity",
+ "model-error-response",
+ "model_user",
+ "models_bulk_upload",
+ "models_permissions",
+ "rootcause",
+ "s3_key",
+ "serde",
+ "serde_json",
+ "sqlx",
+ "sqs_client",
+ "system_properties",
+ "thiserror 2.0.18",
+ "tokio",
+ "tower 0.5.3",
+ "tracing",
+ "unicode-segmentation",
+ "utoipa",
+ "uuid",
+ "workspace-hack",
+]
+
[[package]]
name = "prompt"
version = "0.1.0"
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/deleteProjectHandler200DataOneOf.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/deleteProjectHandler200DataOneOf.ts
index f7efd4cbeb..62319fa59c 100644
--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/deleteProjectHandler200DataOneOf.ts
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/deleteProjectHandler200DataOneOf.ts
@@ -5,11 +5,14 @@
* OpenAPI spec version: 0.1.0
*/
+/**
+ * Identifiers affected by a recursive project soft deletion.
+ */
export type DeleteProjectHandler200DataOneOf = {
- /** The ids of the chats that were marked as deleted */
+ /** Deleted chats. */
chat_ids: string[];
- /** The ids of the documents that were marked as deleted */
+ /** Deleted documents. */
document_ids: string[];
- /** The ids of the project that were marked as deleted */
+ /** Deleted projects, including the requested root. */
project_ids: string[];
};
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/projectDeleteResponseData.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/projectDeleteResponseData.ts
index 24a005ed96..3ab02af3f5 100644
--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/projectDeleteResponseData.ts
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/projectDeleteResponseData.ts
@@ -5,11 +5,14 @@
* OpenAPI spec version: 0.1.0
*/
+/**
+ * Identifiers affected by a recursive project soft deletion.
+ */
export interface ProjectDeleteResponseData {
- /** The ids of the chats that were marked as deleted */
+ /** Deleted chats. */
chat_ids: string[];
- /** The ids of the documents that were marked as deleted */
+ /** Deleted documents. */
document_ids: string[];
- /** The ids of the project that were marked as deleted */
+ /** Deleted projects, including the requested root. */
project_ids: string[];
}
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/zod.ts b/apps/web/src/lib/service-clients/service-storage/generated/zod.ts
index b0ef0fee57..fe577f1eee 100644
--- a/apps/web/src/lib/service-clients/service-storage/generated/zod.ts
+++ b/apps/web/src/lib/service-clients/service-storage/generated/zod.ts
@@ -19740,7 +19740,7 @@ export const removePinHandlerResponse = zod.object({
});
/**
- * @summary Gets all the users projects. This includes projects shared with the user.
+ * @summary List projects visible to the authenticated user.
*/
export const getProjectsHandlerResponse = zod.object({
data: zod
@@ -19767,8 +19767,7 @@ export const getProjectsHandlerResponse = zod.object({
});
/**
- * @summary Creates a new project.
-The project can be created as a sub-project of another project or as a top-level project.
+ * @summary Create a project, optionally beneath an existing project.
*/
export const createProjectHandlerBody = zod.object({
name: zod.string().describe('The name of the project.'),
@@ -19799,7 +19798,7 @@ export const createProjectHandlerResponse = zod.object({
});
/**
- * @summary Gets all the users projects that are pending upload. This includes projects shared with the user.
+ * @summary List pending root projects owned by the authenticated user.
*/
export const getPendingProjectsHandlerResponse = zod.object({
data: zod
@@ -19840,6 +19839,9 @@ export const getPendingProjectsHandlerResponse = zod.object({
error: zod.boolean().describe('Indicates if an error occurred'),
});
+/**
+ * @summary Get previews for a batch of project IDs.
+ */
export const getBatchProjectPreviewBody = zod.object({
projectIds: zod.array(zod.string()),
});
@@ -19883,8 +19885,7 @@ export const getBatchProjectPreviewResponse = zod.object({
});
/**
- * @summary Uploads a folder to the user's cloud storage. Mimicing the folder structure
-with projects and placing all documents in the correct location.
+ * @summary Upload a folder tree and create its upload destinations.
*/
export const uploadFolderHandlerBody = zod.object({
content: zod
@@ -20844,9 +20845,7 @@ export const uploadFolderHandlerResponse = zod.object({
});
/**
- * @summary Creates a request id in the dynamodb table for tracking the upload
-Returns a presigned url for uploading a zip file to the staging bucket
-Returns a request id for tracking the upload
+ * @summary Create a request for extracting an uploaded folder archive.
*/
export const uploadExtractFolderHandlerBody = zod.object({
name: zod.string().nullish(),
@@ -20864,6 +20863,9 @@ export const uploadExtractFolderHandlerResponse = zod.object({
error: zod.boolean().describe('Indicates if an error occurred'),
});
+/**
+ * @summary Get project metadata.
+ */
export const getProjectHandlerParams = zod.object({
id: zod.string().describe('ID of the project'),
});
@@ -20894,8 +20896,7 @@ export const getProjectHandlerResponse = zod.object({
});
/**
- * @summary Deletes a project.
-Soft deletes the project and all of its children.
+ * @summary Soft-delete a project and all of its children.
*/
export const deleteProjectHandlerParams = zod.object({
id: zod.string().describe('ID of the project'),
@@ -20904,22 +20905,19 @@ export const deleteProjectHandlerParams = zod.object({
export const deleteProjectHandlerResponse = zod.object({
data: zod
.object({
- chat_ids: zod
- .array(zod.string())
- .describe('The ids of the chats that were marked as deleted'),
- document_ids: zod
- .array(zod.string())
- .describe('The ids of the documents that were marked as deleted'),
+ chat_ids: zod.array(zod.string()).describe('Deleted chats.'),
+ document_ids: zod.array(zod.string()).describe('Deleted documents.'),
project_ids: zod
.array(zod.string())
- .describe('The ids of the project that were marked as deleted'),
+ .describe('Deleted projects, including the requested root.'),
})
+ .describe('Identifiers affected by a recursive project soft deletion.')
.describe('Data to be returned'),
error: zod.boolean().describe('Indicates if an error occurred'),
});
/**
- * @summary Gets the user's access level to the project
+ * @summary Get the caller's project access level.
*/
export const getProjectUserAccessLevelParams = zod.object({
id: zod.string().describe('ID of the project'),
@@ -20930,8 +20928,7 @@ export const getProjectUserAccessLevelResponse = zod
.describe('Ordered from least to most access top -> bottom');
/**
- * @summary Gets the content of a project.
-This includes the projects sub-projects as well as the items in the project.
+ * @summary Get a project's immediate children.
*/
export const getProjectContentHandlerParams = zod.object({
id: zod.string().describe('ID of the project'),
@@ -21084,7 +21081,7 @@ export const getProjectContentHandlerResponse = zod.object({
});
/**
- * @summary Permanently deletes a project and all of it's children.
+ * @summary Permanently delete a soft-deleted project and all of its children.
*/
export const permanentlyDeleteProjectParams = zod.object({
id: zod.string().describe('ID of the project'),
@@ -21098,8 +21095,7 @@ export const permanentlyDeleteProjectResponse = zod.object({
});
/**
- * @summary Gets the current documents share permissions
-Gets the projects share permissions
+ * @summary Get a project's share permissions.
*/
export const getProjectPermissionsV2Params = zod.object({
id: zod.string().describe('ID of the project'),
@@ -21133,7 +21129,7 @@ export const getProjectPermissionsV2Response = zod.object({
});
/**
- * @summary Deletes a specific document
+ * @summary Restore a soft-deleted project and its children.
*/
export const revertDeleteProjectParams = zod.object({
id: zod.string().describe('ID of the project'),
@@ -21500,7 +21496,7 @@ export const getDocumentPermissionsV2Response = zod.object({
});
/**
- * @summary Edits a project.
+ * @summary Edit project metadata and sharing settings.
*/
export const editProjectV2Params = zod.object({
id: zod.string().describe('ID of the project'),
diff --git a/apps/web/src/lib/service-clients/service-storage/openapi.json b/apps/web/src/lib/service-clients/service-storage/openapi.json
index 1d5632e9c9..762db33cb1 100644
--- a/apps/web/src/lib/service-clients/service-storage/openapi.json
+++ b/apps/web/src/lib/service-clients/service-storage/openapi.json
@@ -7965,7 +7965,7 @@
"/projects": {
"get": {
"tags": ["project"],
- "summary": "Gets all the users projects. This includes projects shared with the user.",
+ "summary": "List projects visible to the authenticated user.",
"operationId": "get_projects_handler",
"responses": {
"200": {
@@ -8002,7 +8002,7 @@
},
"post": {
"tags": ["project"],
- "summary": "Creates a new project.\nThe project can be created as a sub-project of another project or as a top-level project.",
+ "summary": "Create a project, optionally beneath an existing project.",
"operationId": "create_project_handler",
"requestBody": {
"content": {
@@ -8051,7 +8051,7 @@
"/projects/pending": {
"get": {
"tags": ["project"],
- "summary": "Gets all the users projects that are pending upload. This includes projects shared with the user.",
+ "summary": "List pending root projects owned by the authenticated user.",
"operationId": "get_pending_projects_handler",
"responses": {
"200": {
@@ -8124,6 +8124,7 @@
"/projects/preview": {
"post": {
"tags": ["project"],
+ "summary": "Get previews for a batch of project IDs.",
"operationId": "get_batch_project_preview",
"requestBody": {
"content": {
@@ -8171,8 +8172,8 @@
},
"/projects/upload": {
"post": {
- "tags": ["projects::upload_folder"],
- "summary": "Uploads a folder to the user's cloud storage. Mimicing the folder structure\nwith projects and placing all documents in the correct location.",
+ "tags": ["projects_hex::inbound::axum_router::upload_folder"],
+ "summary": "Upload a folder tree and create its upload destinations.",
"operationId": "upload_folder_handler",
"requestBody": {
"content": {
@@ -8257,7 +8258,7 @@
"/projects/upload_extract": {
"post": {
"tags": ["project"],
- "summary": "Creates a request id in the dynamodb table for tracking the upload\nReturns a presigned url for uploading a zip file to the staging bucket\nReturns a request id for tracking the upload",
+ "summary": "Create a request for extracting an uploaded folder archive.",
"operationId": "upload_extract_folder_handler",
"requestBody": {
"content": {
@@ -8339,7 +8340,8 @@
},
"/projects/{id}": {
"get": {
- "tags": ["projects::get_project"],
+ "tags": ["projects_hex::inbound::axum_router::get_project"],
+ "summary": "Get project metadata.",
"operationId": "get_project_handler",
"parameters": [
{
@@ -8387,7 +8389,7 @@
},
"delete": {
"tags": ["project"],
- "summary": "Deletes a project.\nSoft deletes the project and all of its children.",
+ "summary": "Soft-delete a project and all of its children.",
"operationId": "delete_project_handler",
"parameters": [
{
@@ -8413,6 +8415,7 @@
"oneOf": [
{
"type": "object",
+ "description": "Identifiers affected by a recursive project soft deletion.",
"required": [
"project_ids",
"document_ids",
@@ -8424,21 +8427,21 @@
"items": {
"type": "string"
},
- "description": "The ids of the chats that were marked as deleted"
+ "description": "Deleted chats."
},
"document_ids": {
"type": "array",
"items": {
"type": "string"
},
- "description": "The ids of the documents that were marked as deleted"
+ "description": "Deleted documents."
},
"project_ids": {
"type": "array",
"items": {
"type": "string"
},
- "description": "The ids of the project that were marked as deleted"
+ "description": "Deleted projects, including the requested root."
}
}
}
@@ -8480,7 +8483,7 @@
"/projects/{id}/access_level": {
"get": {
"tags": ["project"],
- "summary": "Gets the user's access level to the project",
+ "summary": "Get the caller's project access level.",
"operationId": "get_project_user_access_level",
"parameters": [
{
@@ -8540,7 +8543,7 @@
"/projects/{id}/content": {
"get": {
"tags": ["project"],
- "summary": "Gets the content of a project.\nThis includes the projects sub-projects as well as the items in the project.",
+ "summary": "Get a project's immediate children.",
"operationId": "get_project_content_handler",
"parameters": [
{
@@ -8590,7 +8593,7 @@
"/projects/{id}/permanent": {
"delete": {
"tags": ["project"],
- "summary": "Permanently deletes a project and all of it's children.",
+ "summary": "Permanently delete a soft-deleted project and all of its children.",
"operationId": "permanently_delete_project",
"parameters": [
{
@@ -8650,7 +8653,7 @@
"/projects/{id}/permissions": {
"get": {
"tags": ["project"],
- "summary": "Gets the current documents share permissions\nGets the projects share permissions",
+ "summary": "Get a project's share permissions.",
"operationId": "get_project_permissions_v2",
"parameters": [
{
@@ -8700,7 +8703,7 @@
"/projects/{id}/revert_delete": {
"put": {
"tags": ["project"],
- "summary": "Deletes a specific document",
+ "summary": "Restore a soft-deleted project and its children.",
"operationId": "revert_delete_project",
"parameters": [
{
@@ -9341,7 +9344,7 @@
"/v2/projects/{id}": {
"patch": {
"tags": ["project"],
- "summary": "Edits a project.",
+ "summary": "Edit project metadata and sharing settings.",
"operationId": "edit_project_v2",
"parameters": [
{
@@ -17434,6 +17437,7 @@
},
"ProjectDeleteResponseData": {
"type": "object",
+ "description": "Identifiers affected by a recursive project soft deletion.",
"required": ["project_ids", "document_ids", "chat_ids"],
"properties": {
"chat_ids": {
@@ -17441,21 +17445,21 @@
"items": {
"type": "string"
},
- "description": "The ids of the chats that were marked as deleted"
+ "description": "Deleted chats."
},
"document_ids": {
"type": "array",
"items": {
"type": "string"
},
- "description": "The ids of the documents that were marked as deleted"
+ "description": "Deleted documents."
},
"project_ids": {
"type": "array",
"items": {
"type": "string"
},
- "description": "The ids of the project that were marked as deleted"
+ "description": "Deleted projects, including the requested root."
}
}
},
diff --git a/crates/macro_db_client/src/projects/create_project.rs b/crates/macro_db_client/src/projects/create_project.rs
deleted file mode 100644
index be3a2d472d..0000000000
--- a/crates/macro_db_client/src/projects/create_project.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use crate::{history::upsert_user_history, share_permission};
-use macro_user_id::{cowlike::CowLike, user_id::MacroUserIdStr};
-use model::project::Project;
-use models_permissions::share_permission::SharePermissionV2;
-use sqlx::{Pool, Postgres};
-
-#[tracing::instrument(skip(db))]
-pub async fn create_project_v2(
- db: Pool<Postgres>,
- user_id: MacroUserIdStr<'_>,
- project_name: &str,
- parent_id: Option<String>,
- share_permission: &SharePermissionV2,
-) -> anyhow::Result<Project> {
- let mut transaction = db.begin().await?;
- let project = sqlx::query_as!(
- Project,
- r#"
- INSERT INTO "Project" ("name", "userId", "parentId", "createdAt", "updatedAt")
- VALUES ($1, $2, $3, NOW(), NOW())
- RETURNING id, name, "userId"::text as user_id, "createdAt"::timestamptz as created_at, "deletedAt"::timestamptz as deleted_at,
- "updatedAt"::timestamptz as updated_at, "parentId" as parent_id
- "#,
- project_name,
- user_id.as_ref(),
- parent_id,
- )
- .fetch_one(transaction.as_mut())
- .await?;
-
- // Create share permission
- share_permission::create::create_project_permission(
- &mut transaction,
- &project.id,
- share_permission,
- )
- .await?;
-
- upsert_user_history(&mut transaction, user_id.copied(), &project.id, "project").await?;
-
- // SAFETY: this is a UUID
- let project_id = macro_uuid::string_to_uuid(&project.id).unwrap();
-
- entity_access_db_utils::insert_entity_access_row(
- &mut transaction,
- &project_id,
- entity_access_db_utils::EntityType::Project,
- user_id.as_ref(),
- entity_access_db_utils::EntityAccessSourceType::User,
- entity_access_db_utils::AccessLevel::Owner,
- )
- .await?;
-
- transaction.commit().await.map_err(|e| {
- tracing::error!(error=?e, "error committing transaction");
- anyhow::Error::from(e)
- })?;
-
- Ok(project)
-}
diff --git a/crates/macro_db_client/src/projects/delete.rs b/crates/macro_db_client/src/projects/delete.rs
index fbf181dae9..6b7d416ba4 100644
--- a/crates/macro_db_client/src/projects/delete.rs
+++ b/crates/macro_db_client/src/projects/delete.rs
@@ -1,165 +1,7 @@
-use super::get_project::get_project_chats::get_chats_from_project_ids;
-use super::get_project::get_project_documents::get_documents_from_project_ids;
use anyhow::Context;
use model_entity::EntityType;
use sqlx::{Pool, Postgres, Transaction};
-use super::get_project::get_sub_items::get_all_sub_project_ids;
-
-/// Soft deletes a project.
-/// Marks all items within the project and it's sub-projects as deleted.
-/// Returns project_ids, document_ids, and chat_ids that were marked as deleted.
-#[tracing::instrument(skip(db))]
-pub async fn soft_delete_project(
- db: &Pool<Postgres>,
- project_id: &str,
-) -> anyhow::Result<(Vec<String>, Vec<String>, Vec<String>)> {
- let mut transaction = db.begin().await.context("unable to begin transaction")?;
-
- let project_ids = get_all_sub_project_ids(&mut transaction, project_id).await?;
- let chat_ids = get_chats_from_project_ids(db, &project_ids).await?;
- let document_ids = get_documents_from_project_ids(db, &project_ids).await?;
-
- let combined_item_ids = project_ids
- .clone()
- .into_iter()
- .chain(chat_ids.clone())
- .chain(document_ids.clone())
- .collect::<Vec<String>>();
-
- tracing::trace!("deleting pins");
- sqlx::query!(
- r#"
- DELETE FROM "Pin" WHERE "pinnedItemId" = ANY($1)
- "#,
- &combined_item_ids,
- )
- .execute(&mut *transaction)
- .await?;
-
- tracing::trace!("deleting user history");
- sqlx::query!(
- r#"
- DELETE FROM "UserHistory" WHERE "itemId" = ANY($1)
- "#,
- &combined_item_ids,
- )
- .execute(&mut *transaction)
- .await?;
-
- let date = chrono::Utc::now().naive_utc();
-
- tracing::trace!("marking documents as deleted");
- sqlx::query!(
- r#"
- UPDATE "Document" SET "deletedAt" = $2 WHERE id = ANY($1);
- "#,
- &document_ids,
- &date
- )
- .execute(&mut *transaction)
- .await?;
-
- tracing::trace!("marking chats as deleted");
- sqlx::query!(
- r#"
- UPDATE "Chat" SET "deletedAt" = $2 WHERE id = ANY($1);
- "#,
- &chat_ids,
- &date
- )
- .execute(&mut *transaction)
- .await?;
-
- tracing::trace!("marking projects as deleted");
- sqlx::query!(
- r#"
- UPDATE "Project" SET "deletedAt" = $2 WHERE id = ANY($1);
- "#,
- &project_ids,
- &date
- )
- .execute(&mut *transaction)
- .await?;
-
- transaction
- .commit()
- .await
- .context("unable to commit transaction")?;
-
- Ok((project_ids, document_ids, chat_ids))
-}
-
-/// Hard deletes a project.
-pub async fn delete_project(db: Pool<Postgres>, project_id: &str) -> anyhow::Result<()> {
- let mut transaction = db.begin().await?;
-
- // Delete pins
- sqlx::query!(
- r#"
- DELETE FROM "Pin" WHERE "pinnedItemId" = $1 AND "pinnedItemType" = $2
- "#,
- project_id,
- "project",
- )
- .execute(&mut *transaction)
- .await?;
-
- // Delete user history
- sqlx::query!(
- r#"
- DELETE FROM "UserHistory" WHERE "itemId" = $1 AND "itemType" = $2
- "#,
- project_id,
- "project",
- )
- .execute(&mut *transaction)
- .await?;
-
- // Get share permission if present
- let share_permission: Option<String> = sqlx::query!(
- r#"
- SELECT "sharePermissionId" as share_permission_id
- FROM "ProjectPermission"
- WHERE "projectId"=$1"#,
- project_id
- )
- .map(|row| row.share_permission_id)
- .fetch_optional(&mut *transaction)
- .await?;
-
- if let Some(share_permission) = share_permission {
- // Delete share permission
- sqlx::query!(
- r#"
- DELETE FROM "SharePermission" WHERE id = $1"#,
- share_permission
- )
- .execute(&mut *transaction)
- .await?;
- }
-
- crate::item_access::delete::delete_user_entity_access_by_item(
- &mut transaction,
- &macro_uuid::string_to_uuid(project_id).unwrap(),
- EntityType::Project,
- )
- .await?;
-
- sqlx::query!(
- r#"
- DELETE FROM "Project"
- WHERE id = $1"#,
- project_id
- )
- .execute(&mut *transaction)
- .await?;
-
- transaction.commit().await?;
-
- Ok(())
-}
-
#[tracing::instrument(skip(db))]
pub async fn delete_projects_bulk(
db: &Pool<Postgres>,
diff --git a/crates/macro_db_client/src/projects/edit_project.rs b/crates/macro_db_client/src/projects/edit_project.rs
deleted file mode 100644
index 8ee97fb3dd..0000000000
--- a/crates/macro_db_client/src/projects/edit_project.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use sqlx::{Pool, Postgres};
-
-use crate::share_permission;
-use model::project::Project;
-
-pub async fn update_project_modified_date(
- db: &Pool<Postgres>,
- project_id: &str,
-) -> anyhow::Result<()> {
- sqlx::query!(
- r#"UPDATE "Project" SET "updatedAt" = NOW() WHERE id = $1"#,
- project_id,
- )
- .execute(db)
- .await?;
-
- Ok(())
-}
-
-#[tracing::instrument(skip(transaction))]
-#[allow(clippy::disallowed_methods, reason = "legacy code. fix later")]
-pub async fn edit_project_v2(
- transaction: &mut sqlx::Transaction<'_, Postgres>,
- user_id: &str,
- project_id: &str,
- project_name: Option<&str>,
- parent_id: Option<&str>,
- share_permission: Option<&models_permissions::share_permission::UpdateSharePermissionRequestV2>,
-) -> anyhow::Result<Project> {
- let mut query = "UPDATE \"Project\" SET ".to_string();
- let mut parameters: Vec<Option<&str>> = Vec::new();
- let mut set_parts = Vec::new();
-
- if let Some(name) = project_name {
- set_parts.push("\"name\" = $".to_string() + &(set_parts.len() + 2).to_string());
- parameters.push(Some(name));
- }
-
- if let Some(parent_id) = parent_id {
- set_parts.push("\"parentId\" = $".to_string() + &(set_parts.len() + 2).to_string());
- if parent_id.is_empty() {
- parameters.push(None);
- } else {
- parameters.push(Some(parent_id));
- }
- }
-
- query += &set_parts.join(", ");
- if !set_parts.is_empty() {
- query += ", ";
- }
- query += "\"updatedAt\" = NOW() WHERE id = $1 RETURNING id, name, \"userId\"::text as user_id, \"parentId\" as parent_id, \"createdAt\"::timestamptz as created_at, \"updatedAt\"::timestamptz as updated_at, \"deletedAt\"::timestamptz as deleted_at";
-
- let mut query = sqlx::query_as::<_, Project>(&query);
- query = query.bind(project_id);
- for param in parameters {
- query = query.bind(param);
- }
-
- let updated_project = query.fetch_one(transaction.as_mut()).await?;
-
- if let Some(share_permission) = share_permission {
- share_permission::edit::edit_project_permission(transaction, project_id, share_permission)
- .await?;
- }
-
- Ok(updated_project)
-}
diff --git a/crates/macro_db_client/src/projects/get_project/get_project_by_id.rs b/crates/macro_db_client/src/projects/get_project/get_project_by_id.rs
index 0e8f572931..9921050cfa 100644
--- a/crates/macro_db_client/src/projects/get_project/get_project_by_id.rs
+++ b/crates/macro_db_client/src/projects/get_project/get_project_by_id.rs
@@ -2,8 +2,8 @@ use sqlx::{Pool, Postgres};
use model::project::Project;
-/// Fetch a project row for search indexing. Unlike [`get_project_by_id`],
-/// soft-deleted rows are returned so the caller can turn the upsert into a
+/// Fetch a project row for search indexing. Soft-deleted rows are returned
+/// so the caller can turn the upsert into a
/// removal, and a missing row maps to `None` instead of an error.
#[tracing::instrument(skip(db), err)]
pub async fn get_project_for_search(
@@ -31,51 +31,3 @@ pub async fn get_project_for_search(
Ok(result)
}
-
-#[tracing::instrument(skip(db))]
-pub async fn get_project_by_id(
- db: Pool<Postgres>,
- project_id: &str,
-) -> Result<Project, sqlx::Error> {
- let result = sqlx::query_as!(
- Project,
- r#"
- SELECT
- p.id,
- p.name,
- p."userId" as user_id,
- p."parentId" as parent_id,
- p."createdAt"::timestamptz as created_at,
- p."updatedAt"::timestamptz as updated_at,
- p."deletedAt"::timestamptz as deleted_at
- FROM "Project" p
- WHERE id = $1 AND p."deletedAt" IS NULL
- "#,
- project_id
- )
- .fetch_one(&db)
- .await?;
-
- Ok(result)
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use sqlx::{Pool, Postgres};
-
- #[sqlx::test(fixtures(path = "../../../fixtures", scripts("users", "projects")))]
- async fn test_get_project_by_id(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let project = get_project_by_id(pool.clone(), &"p1").await?;
- assert_eq!(project.id, "p1".to_string());
- Ok(())
- }
-
- #[sqlx::test(fixtures(path = "../../../fixtures", scripts("users", "projects")))]
- async fn test_get_project_by_id_not_found(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let result = get_project_by_id(pool.clone(), &"project-bad").await;
- assert!(result.is_err());
- assert!(matches!(result, Err(sqlx::Error::RowNotFound)));
- Ok(())
- }
-}
diff --git a/crates/macro_db_client/src/projects/get_project/get_project_chats.rs b/crates/macro_db_client/src/projects/get_project/get_project_chats.rs
deleted file mode 100644
index b37ea20d02..0000000000
--- a/crates/macro_db_client/src/projects/get_project/get_project_chats.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-/// Get all the chats from a list of project ids
-#[tracing::instrument(skip(db))]
-pub async fn get_chats_from_project_ids(
- db: &sqlx::Pool<sqlx::Postgres>,
- project_ids: &Vec<String>,
-) -> anyhow::Result<Vec<String>> {
- let result = sqlx::query!(
- r#"
- SELECT "id" FROM "Chat" WHERE "projectId" = ANY($1)
- "#,
- project_ids
- )
- .map(|row| row.id)
- .fetch_all(db)
- .await?;
-
- Ok(result)
-}
-
-/// Get all deleted chats from a list of project ids
-/// Returns the id and the owner of the chat
-#[tracing::instrument(skip(db))]
-pub async fn get_deleted_chats_from_project_ids(
- db: &sqlx::Pool<sqlx::Postgres>,
- project_ids: &[impl ToString + std::fmt::Debug],
-) -> anyhow::Result<Vec<(String, String)>> {
- let project_ids: Vec<String> = project_ids.iter().map(|s| s.to_string()).collect();
- let result = sqlx::query!(
- r#"
- SELECT "id", "userId" as user_id FROM "Chat" WHERE "projectId" = ANY($1) AND "deletedAt" IS NOT NULL
- "#,
- &project_ids
- )
- .map(|row| (row.id, row.user_id))
- .fetch_all(db)
- .await?;
-
- Ok(result)
-}
-
-#[tracing::instrument(skip(db))]
-pub async fn get_chat_permission_ids(
- db: &sqlx::Pool<sqlx::Postgres>,
- chat_ids: &Vec<String>,
-) -> anyhow::Result<Vec<String>> {
- let result = sqlx::query!(
- r#"
- SELECT "sharePermissionId" as id FROM "ChatPermission" WHERE "chatId" = ANY($1)
- "#,
- chat_ids
- )
- .map(|row| row.id)
- .fetch_all(db)
- .await?;
-
- Ok(result)
-}
diff --git a/crates/macro_db_client/src/projects/get_project/get_project_content.rs b/crates/macro_db_client/src/projects/get_project/get_project_content.rs
deleted file mode 100644
index f6e1485432..0000000000
--- a/crates/macro_db_client/src/projects/get_project/get_project_content.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-use super::get_sub_items;
-use macro_user_id::user_id::MacroUserIdStr;
-use model::item::{Item, ItemWithUserAccessLevel};
-use models_permissions::share_permission::access_level::AccessLevel;
-use sqlx::{Pool, Postgres};
-
-/// Gets the content of a project to a depth of 1.
-/// This includes the projects sub-projects as well as the documents/chats in the project.
-/// This returns in order of all projects, documents, then chats.
-/// The user access level will be
-#[tracing::instrument(skip(db))]
-pub async fn get_project_content_v2(
- db: &Pool<Postgres>,
- project_id: &str,
- user_id: MacroUserIdStr<'_>,
- project_user_access_level: AccessLevel,
-) -> anyhow::Result<Vec<ItemWithUserAccessLevel>> {
- let mut transaction = db.begin().await?;
-
- let sub_projects = get_sub_items::get_sub_projects(&mut transaction, project_id).await?;
- let sub_projects: Vec<ItemWithUserAccessLevel> = sub_projects
- .into_iter()
- .map(|p| {
- let user_access_level = match p.user_id == user_id.as_ref() {
- true => AccessLevel::Owner,
- false => project_user_access_level,
- };
- ItemWithUserAccessLevel {
- item: Item::Project(p),
- user_access_level,
- }
- })
- .collect();
-
- let sub_documents = get_sub_items::get_sub_documents(&mut transaction, project_id).await?;
- let sub_documents: Vec<ItemWithUserAccessLevel> = sub_documents
- .into_iter()
- .map(|d| {
- let user_access_level = match d.owner == user_id {
- true => AccessLevel::Owner,
- false => project_user_access_level,
- };
- ItemWithUserAccessLevel {
- item: Item::Document(d),
- user_access_level,
- }
- })
- .collect();
-
- let sub_chats = get_sub_items::get_sub_chats(&mut transaction, project_id).await?;
- let sub_chats: Vec<ItemWithUserAccessLevel> = sub_chats
- .into_iter()
- .map(|c| {
- let user_access_level = match c.user_id == user_id.as_ref() {
- true => AccessLevel::Owner,
- false => project_user_access_level,
- };
- ItemWithUserAccessLevel {
- item: Item::Chat(c),
- user_access_level,
- }
- })
- .collect();
-
- let mut result: Vec<ItemWithUserAccessLevel> = vec![];
- result.extend(sub_projects);
- result.extend(sub_documents);
- result.extend(sub_chats);
-
- Ok(result)
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use model::item::Item;
- use models_permissions::share_permission::access_level::AccessLevel;
- use sqlx::{Pool, Postgres};
-
- #[sqlx::test(fixtures(
- path = "../../../fixtures",
- scripts("users", "projects", "documents", "chats")
- ))]
- async fn test_get_project_content_v2(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let result = get_project_content_v2(
- &pool,
- "p1",
- MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap(),
- AccessLevel::View,
- )
- .await?;
-
- let mapped_result: Vec<(String, String)> = result
- .into_iter()
- .map(|p| match p.item {
- Item::Project(p) => (p.id, "project".to_string()),
- Item::Document(d) => (d.document_id, "document".to_string()),
- Item::Chat(c) => (c.id, "chat".to_string()),
- })
- .collect();
-
- assert_eq!(
- mapped_result,
- vec![
- ("p2".to_string(), "project".to_string()),
- ("p3".to_string(), "project".to_string()),
- ("p4".to_string(), "project".to_string()),
- ("p5".to_string(), "project".to_string()),
- ("d1".to_string(), "document".to_string()),
- ("d3".to_string(), "document".to_string()), // This is included in v2 because the user has access to the project so they'll have access to all items inside
- ("c1".to_string(), "chat".to_string()),
- ]
- );
-
- Ok(())
- }
-}
diff --git a/crates/macro_db_client/src/projects/get_project/get_project_documents.rs b/crates/macro_db_client/src/projects/get_project/get_project_documents.rs
deleted file mode 100644
index d1299cbffa..0000000000
--- a/crates/macro_db_client/src/projects/get_project/get_project_documents.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-/// Get all the documents from a list of project ids
-#[tracing::instrument(skip(db))]
-pub async fn get_documents_from_project_ids(
- db: &sqlx::Pool<sqlx::Postgres>,
- project_ids: &Vec<String>,
-) -> anyhow::Result<Vec<String>> {
- let result = sqlx::query!(
- r#"
- SELECT "id" FROM "Document" WHERE "projectId" = ANY($1)
- "#,
- project_ids
- )
- .map(|row| row.id)
- .fetch_all(db)
- .await?;
-
- Ok(result)
-}
-
-/// Get all deleted documents from a list of project ids
-#[tracing::instrument(skip(db))]
-pub async fn get_deleted_documents_from_project_ids(
- db: &sqlx::Pool<sqlx::Postgres>,
- project_ids: &[impl ToString + std::fmt::Debug],
-) -> anyhow::Result<Vec<(String, String)>> {
- let project_ids: Vec<String> = project_ids.iter().map(|s| s.to_string()).collect();
- let result = sqlx::query!(
- r#"
- SELECT id, owner FROM "Document" WHERE "projectId" = ANY($1) AND "deletedAt" IS NOT NULL
- "#,
- &project_ids
- )
- .map(|row| (row.id, row.owner))
- .fetch_all(db)
- .await?;
-
- Ok(result)
-}
-
-#[tracing::instrument(skip(db))]
-pub async fn get_document_permission_ids(
- db: &sqlx::Pool<sqlx::Postgres>,
- document_ids: &Vec<String>,
-) -> anyhow::Result<Vec<String>> {
- let result = sqlx::query!(
- r#"
- SELECT "sharePermissionId" as id FROM "DocumentPermission" WHERE "documentId" = ANY($1)
- "#,
- document_ids
- )
- .map(|row| row.id)
- .fetch_all(db)
- .await?;
-
- Ok(result)
-}
diff --git a/crates/macro_db_client/src/projects/get_project/get_sub_items.rs b/crates/macro_db_client/src/projects/get_project/get_sub_items.rs
index 6210556601..cf50898f35 100644
--- a/crates/macro_db_client/src/projects/get_project/get_sub_items.rs
+++ b/crates/macro_db_client/src/projects/get_project/get_sub_items.rs
@@ -1,212 +1,9 @@
-use document_sub_type::DocumentSubType;
-use macro_user_id::{cowlike::CowLike, user_id::MacroUserIdStr};
-use model::{
- chat::Chat,
- document::{BasicDocument, BasicDocumentSubType},
- project::Project,
-};
-use system_properties::{StatusOption, SystemPropertyKey};
-
-/// Gets all deleted sub-projects of a given project.
-/// Includes the root project itself as well.
-/// Returns the id and the owner of the project
-#[tracing::instrument(skip(transaction))]
-pub async fn get_all_deleted_sub_project_ids(
- transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
- project_id: &str,
-) -> anyhow::Result<Vec<(String, String)>> {
- // Get all items (documents, chats, compare, sub-projects for a given project id)
- let result = sqlx::query!(
- r#"
- WITH RECURSIVE project_hierarchy AS (
- SELECT
- p.id,
- p."userId" as user_id
- FROM "Project" p
- WHERE p.id = $1 AND p."deletedAt" IS NOT NULL
- UNION ALL
- SELECT
- sub_p.id,
- sub_p."userId" as user_id
- FROM "Project" sub_p
- INNER JOIN project_hierarchy ph ON sub_p."parentId" = ph.id
- WHERE sub_p."deletedAt" IS NOT NULL
- )
- SELECT
- ph.id as "id!",
- ph.user_id as "user_id!"
- FROM project_hierarchy ph
- "#,
- project_id,
- )
- .map(|r| (r.id, r.user_id))
- .fetch_all(transaction.as_mut())
- .await?;
-
- Ok(result)
-}
-
-/// Gets all projects inside of a project.
-#[tracing::instrument(skip(transaction))]
-pub async fn get_sub_projects(
- transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
- project_id: &str,
-) -> anyhow::Result<Vec<Project>> {
- let projects: Vec<Project> = sqlx::query_as!(
- Project,
- r#"
- SELECT
- p.id as id,
- p.name,
- p."userId" as user_id,
- p."parentId" as "parent_id?",
- p."createdAt"::timestamptz as created_at,
- p."updatedAt"::timestamptz as updated_at,
- p."deletedAt"::timestamptz as deleted_at
- FROM
- "Project" p
- WHERE p."parentId" = $1 AND p."deletedAt" IS NULL
- "#,
- project_id,
- )
- .fetch_all(transaction.as_mut())
- .await?;
-
- Ok(projects)
-}
-
-/// Gets the documents for a given project.
-#[tracing::instrument(skip(transaction))]
-pub async fn get_sub_documents(
- transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
- project_id: &str,
-) -> anyhow::Result<Vec<BasicDocument>> {
- let status_property_id = SystemPropertyKey::STATUS_UUID;
- let completed_option_id = StatusOption::COMPLETED_UUID.to_string();
-
- let documents: Vec<BasicDocument> = sqlx::query!(
- r#"
- SELECT
- d.id as document_id,
- d.owner as owner,
- d.name as document_name,
- COALESCE(db.id, di.id) as "document_version_id!",
- d."fileType" as "file_type?",
- d."createdAt"::timestamptz as created_at,
- d."updatedAt"::timestamptz as updated_at,
- d."projectId" as "project_id?",
- dt.sub_type as "sub_type?: DocumentSubType",
- CASE
- WHEN dt.sub_type = 'task'
- AND ep_status.values->'value' ? $2
- THEN true
- WHEN dt.sub_type = 'task'
- THEN false
- ELSE NULL
- END as "is_completed"
- FROM
- "Document" d
- LEFT JOIN document_sub_type dt ON dt.document_id = d.id
- LEFT JOIN entity_properties ep_status
- ON dt.sub_type = 'task'
- AND ep_status.entity_id = d.id
- AND ep_status.entity_type = 'TASK'
- AND ep_status.property_definition_id = $3
- LEFT JOIN LATERAL (
- SELECT
- b.id
- FROM
- "DocumentBom" b
- WHERE
- b."documentId" = d.id
- ORDER BY
- b."createdAt" DESC
- LIMIT 1
- ) db ON d."fileType" = 'docx'
- LEFT JOIN LATERAL (
- SELECT
- i.id,
- i."documentId",
- i."createdAt",
- i."updatedAt"
- FROM
- "DocumentInstance" i
- WHERE
- i."documentId" = d.id
- ORDER BY
- i."updatedAt" DESC
- LIMIT 1
- ) di ON d."fileType" IS DISTINCT FROM 'docx'
- WHERE d."projectId" = $1 AND d."deletedAt" IS NULL
- "#,
- project_id,
- completed_option_id,
- status_property_id,
- )
- .try_map(|row| {
- Ok(BasicDocument {
- document_id: row.document_id,
- document_name: row.document_name,
- document_version_id: row.document_version_id,
- owner: MacroUserIdStr::parse_from_str(&row.owner)
- .map_err(|e| sqlx::Error::Decode(Box::new(e)))?
- .into_owned(),
- file_type: row.file_type,
- project_id: row.project_id,
- sha: None,
- branched_from_id: None,
- branched_from_version_id: None,
- document_family_id: None,
- created_at: row.created_at,
- updated_at: row.updated_at,
- deleted_at: None, // Don't care about the deleted_at
- sub_type: BasicDocumentSubType::from_db(row.sub_type, row.is_completed),
- })
- })
- .fetch_all(transaction.as_mut())
- .await?;
-
- Ok(documents)
-}
-
-/// Gets the chats for a given project.
-#[tracing::instrument(skip(transaction))]
-pub async fn get_sub_chats(
- transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
- project_id: &str,
-) -> anyhow::Result<Vec<Chat>> {
- let chats: Vec<Chat> = sqlx::query_as!(
- Chat,
- r#"
- SELECT
- c.id as id,
- c.name as name,
- c."userId" as user_id,
- c.model as "model?",
- c."projectId" as "project_id?",
- c."tokenCount" as token_count,
- c."createdAt"::timestamptz as created_at,
- c."updatedAt"::timestamptz as updated_at,
- c."deletedAt"::timestamptz as deleted_at,
- c."isPersistent" as is_persistent
- FROM
- "Chat" c
- WHERE c."projectId" = $1 AND c."deletedAt" IS NULL
- "#,
- project_id,
- )
- .fetch_all(transaction.as_mut())
- .await?;
-
- Ok(chats)
-}
-
-/// Gets all sub-projects of a given list of project ids.
-/// Includes the original project ids as well.
+/// Gets all sub-projects of a given list of project IDs.
+/// Includes the original project IDs as well.
#[tracing::instrument(skip(db), err)]
pub async fn bulk_get_all_sub_project_ids(
db: &sqlx::PgPool,
- project_id: &[String],
+ project_ids: &[String],
) -> anyhow::Result<Vec<String>> {
let result = sqlx::query!(
r#"
@@ -226,71 +23,14 @@ pub async fn bulk_get_all_sub_project_ids(
ph.id as "id!"
FROM project_hierarchy ph
"#,
- &project_id,
+ project_ids,
)
- .map(|r| r.id)
+ .map(|row| row.id)
.fetch_all(db)
.await?;
Ok(result)
}
-/// Gets all sub-projects of a given project.
-/// Includes the root project itself as well.
-#[tracing::instrument(skip(transaction))]
-pub async fn get_all_sub_project_ids(
- transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
- project_id: &str,
-) -> anyhow::Result<Vec<String>> {
- // Get all items (documents, chats, compare, sub-projects for a given project id)
- let result = sqlx::query!(
- r#"
- WITH RECURSIVE project_hierarchy AS (
- SELECT
- p.id
- FROM "Project" p
- WHERE p.id = $1 AND p."deletedAt" IS NULL
- UNION ALL
- SELECT
- sub_p.id
- FROM "Project" sub_p
- INNER JOIN project_hierarchy ph ON sub_p."parentId" = ph.id
- WHERE sub_p."deletedAt" IS NULL
- )
- SELECT
- ph.id as "id!"
- FROM project_hierarchy ph
- "#,
- project_id,
- )
- .map(|r| r.id)
- .fetch_all(transaction.as_mut())
- .await?;
-
- Ok(result)
-}
-
-#[tracing::instrument(skip(transaction))]
-pub async fn get_projects_document_ids(
- transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
- project_ids: &Vec<String>,
-) -> anyhow::Result<Vec<String>> {
- let result = sqlx::query!(
- r#"
- SELECT
- d.id
- FROM
- "Document" d
- WHERE
- d."projectId" = ANY($1::text[])
- "#,
- project_ids
- )
- .fetch_all(transaction.as_mut())
- .await?;
-
- Ok(result.iter().map(|r| r.id.clone()).collect())
-}
-
#[cfg(test)]
mod test;
diff --git a/crates/macro_db_client/src/projects/get_project/get_sub_items/test.rs b/crates/macro_db_client/src/projects/get_project/get_sub_items/test.rs
index 416ab149c1..21f0a4e638 100644
--- a/crates/macro_db_client/src/projects/get_project/get_sub_items/test.rs
+++ b/crates/macro_db_client/src/projects/get_project/get_sub_items/test.rs
@@ -1,23 +1,6 @@
use super::*;
use sqlx::{Pool, Postgres};
-#[sqlx::test(fixtures(path = "../../../../fixtures", scripts("users", "project-content")))]
-async fn test_get_projects_document_ids(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let mut transaction = pool.begin().await?;
-
- let project_ids =
- get_projects_document_ids(&mut transaction, &vec!["p1".to_string(), "p6".to_string()])
- .await?;
-
- assert_eq!(project_ids.len(), 2);
- assert_eq!(project_ids[0], "document-one");
- assert_eq!(project_ids[1], "document-two");
-
- transaction.commit().await?;
-
- Ok(())
-}
-
#[sqlx::test(fixtures(path = "../../../../fixtures", scripts("users", "sub_projects")))]
async fn test_bulk_get_all_sub_project_ids(pool: Pool<Postgres>) -> anyhow::Result<()> {
let project_ids = vec!["p1".to_string(), "p2".to_string(), "p99".to_string()];
diff --git a/crates/macro_db_client/src/projects/get_project/get_sub_projects.rs b/crates/macro_db_client/src/projects/get_project/get_sub_projects.rs
deleted file mode 100644
index 1b1f876e81..0000000000
--- a/crates/macro_db_client/src/projects/get_project/get_sub_projects.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#[tracing::instrument(skip(db))]
-pub async fn get_project_permission_ids(
- db: &sqlx::Pool<sqlx::Postgres>,
- project_ids: &Vec<String>,
-) -> anyhow::Result<Vec<String>> {
- let result = sqlx::query!(
- r#"
- SELECT "sharePermissionId" as id FROM "ProjectPermission" WHERE "projectId" = ANY($1)
- "#,
- project_ids
- )
- .map(|row| row.id)
- .fetch_all(db)
- .await?;
-
- Ok(result)
-}
diff --git a/crates/macro_db_client/src/projects/get_project/mod.rs b/crates/macro_db_client/src/projects/get_project/mod.rs
index 07b7ce0745..77eaa8daee 100644
--- a/crates/macro_db_client/src/projects/get_project/mod.rs
+++ b/crates/macro_db_client/src/projects/get_project/mod.rs
@@ -1,11 +1,6 @@
mod get_project_by_id;
-mod get_project_content;
pub mod get_sub_items;
-pub mod get_sub_projects;
pub mod get_basic_project;
-pub mod get_project_chats;
-pub mod get_project_documents;
-pub use get_project_by_id::{get_project_by_id, get_project_for_search};
-pub use get_project_content::get_project_content_v2;
+pub use get_project_by_id::get_project_for_search;
diff --git a/crates/macro_db_client/src/projects/get_projects.rs b/crates/macro_db_client/src/projects/get_projects.rs
index 1a9f1ecd35..7a4dddce09 100644
--- a/crates/macro_db_client/src/projects/get_projects.rs
+++ b/crates/macro_db_client/src/projects/get_projects.rs
@@ -1,8 +1,6 @@
use chrono::{DateTime, Utc};
use sqlx::{Pool, Postgres};
-use model::project::{Project, ProjectWithUploadRequest};
-
/// One row of the search-backfill scan: just enough to build an upsert
/// message and the keyset cursor.
pub struct ProjectSearchBackfillRow {
@@ -75,77 +73,6 @@ pub async fn get_sub_project_ids(
Ok(result)
}
-/// Gets all projects that the user has viewed
-#[tracing::instrument(skip(db))]
-pub async fn get_projects(db: Pool<Postgres>, user_id: &str) -> anyhow::Result<Vec<Project>> {
- let result = sqlx::query_as!(
- Project,
- r#"
- SELECT
- p.id,
- p.name,
- p."userId" as user_id, -- createor of the project
- p."parentId" as parent_id,
- p."createdAt"::timestamptz as created_at,
- p."updatedAt"::timestamptz as updated_at,
- p."deletedAt"::timestamptz as deleted_at
- FROM "UserHistory" up
- INNER JOIN "Project" p ON up."itemId" = p.id AND up."itemType" = 'project'
- WHERE up."userId" = $1 AND p."deletedAt" IS NULL AND p."uploadPending" = false
- ORDER BY p."updatedAt" DESC
- "#,
- user_id
- )
- .fetch_all(&db)
- .await?;
-
- Ok(result)
-}
-
-/// Gets root projects that the user has viewed + upload status
-#[tracing::instrument(skip(db))]
-pub async fn get_pending_root_projects(
- db: Pool<Postgres>,
- user_id: &str,
-) -> anyhow::Result<Vec<ProjectWithUploadRequest>> {
- let rows = sqlx::query!(
- r#"
- SELECT
- p.id,
- p.name,
- p."userId" as user_id,
- p."parentId" as parent_id,
- p."createdAt"::timestamptz as created_at,
- p."updatedAt"::timestamptz as updated_at,
- p."uploadRequestId" as upload_request_id
- FROM "Project" p
- WHERE p."userId" = $1 AND p."deletedAt" IS NULL AND p."uploadPending" = true AND p."parentId" IS NULL
- ORDER BY p."updatedAt" DESC
- "#,
- user_id,
- )
- .fetch_all(&db)
- .await?;
-
- let projects = rows
- .into_iter()
- .map(|row| ProjectWithUploadRequest {
- project: Project {
- id: row.id,
- name: row.name,
- user_id: row.user_id,
- parent_id: row.parent_id,
- created_at: row.created_at,
- updated_at: row.updated_at,
- deleted_at: None, // Don't care about the deleted_at
- },
- upload_request_id: row.upload_request_id,
- })
- .collect::<Vec<ProjectWithUploadRequest>>();
-
- Ok(projects)
-}
-
/// Gets all projects that are older than the provided date
#[tracing::instrument(skip(db))]
pub async fn get_projects_to_delete(
@@ -198,39 +125,3 @@ pub async fn get_all_project_ids_with_users_paginated(
Ok(result)
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use sqlx::{Pool, Postgres};
-
- #[sqlx::test(fixtures(path = "../../fixtures", scripts("users", "get_projects_example")))]
- async fn test_get_projects(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let projects = get_projects(pool.clone(), "macro|[email protected]").await?;
- assert_eq!(projects.len(), 3);
-
- let project_ids: Vec<String> = projects.iter().map(|project| project.id.clone()).collect();
-
- assert_eq!(
- project_ids,
- vec!["p11".to_string(), "pb1".to_string(), "p1".to_string()]
- );
-
- Ok(())
- }
-
- #[sqlx::test(fixtures(path = "../../fixtures", scripts("users", "get_projects_example")))]
- async fn test_get_pending_projects(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let projects = get_pending_root_projects(pool.clone(), "macro|[email protected]").await?;
- assert_eq!(projects.len(), 1);
-
- let project_ids: Vec<String> = projects
- .iter()
- .map(|project| project.project.id.clone())
- .collect();
-
- assert_eq!(project_ids, vec!["p3".to_string()]);
-
- Ok(())
- }
-}
diff --git a/crates/macro_db_client/src/projects/mod.rs b/crates/macro_db_client/src/projects/mod.rs
index 63bc1cc0b0..fc83688760 100644
--- a/crates/macro_db_client/src/projects/mod.rs
+++ b/crates/macro_db_client/src/projects/mod.rs
@@ -1,19 +1,10 @@
-mod create_project;
-mod edit_project;
pub mod get_project;
mod get_projects;
-pub mod nested_projects;
-pub mod preview;
-pub mod upload_folder;
-pub use create_project::create_project_v2;
-pub use edit_project::{edit_project_v2, update_project_modified_date};
pub use get_projects::{
- ProjectSearchBackfillRow, get_all_project_ids_with_users_paginated, get_pending_root_projects,
- get_projects, get_projects_for_search_backfill, get_projects_to_delete, get_sub_project_ids,
+ ProjectSearchBackfillRow, get_all_project_ids_with_users_paginated,
+ get_projects_for_search_backfill, get_projects_to_delete, get_sub_project_ids,
};
-pub use preview::batch_get_project_preview_v2;
pub mod delete;
pub mod get_project_history;
pub mod move_item;
-pub mod revert_delete;
diff --git a/crates/macro_db_client/src/projects/nested_projects.rs b/crates/macro_db_client/src/projects/nested_projects.rs
deleted file mode 100644
index 4f445d4068..0000000000
--- a/crates/macro_db_client/src/projects/nested_projects.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use sqlx::{Pool, Postgres};
-
-use super::get_project::get_sub_items::get_all_sub_project_ids;
-
-#[tracing::instrument(skip(db))]
-pub async fn is_project_recursively_nested(
- db: Pool<Postgres>,
- project_id: &str,
- parent_id: &str,
-) -> anyhow::Result<Option<String>> {
- // get the projects sub-projects
- let mut transaction = db.begin().await?;
- let sub_projects = get_all_sub_project_ids(&mut transaction, project_id).await?;
- transaction.commit().await?;
-
- // Filter out the project itself
- let sub_projects = sub_projects
- .into_iter()
- .filter_map(|p| {
- if p == project_id {
- return None;
- }
- Some(p)
- })
- .collect::<Vec<String>>();
-
- if sub_projects.is_empty() {
- return Ok(None);
- }
-
- let conflicting_project = sub_projects
- .into_iter()
- .filter(|id| id == parent_id)
- .collect::<Vec<String>>();
-
- if conflicting_project.is_empty() {
- return Ok(None);
- }
-
- Ok(Some(conflicting_project.join(", ")))
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use sqlx::{Pool, Postgres};
-
- #[derive(Debug, Clone, PartialEq, Eq)]
- struct TestFixture<'a> {
- project_id: &'a str,
- parent_id: &'a str,
- expected_result: Option<String>,
- }
-
- #[sqlx::test(fixtures(path = "../../fixtures", scripts("users", "projects")))]
- async fn test_is_project_recursively_nested(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let tests: Vec<TestFixture> = vec![
- TestFixture {
- project_id: "p1",
- parent_id: "pb1",
- expected_result: None,
- },
- TestFixture {
- project_id: "p2",
- parent_id: "pb1",
- expected_result: None,
- },
- TestFixture {
- project_id: "pb1",
- parent_id: "p11",
- expected_result: None,
- },
- TestFixture {
- project_id: "p6",
- parent_id: "p1",
- expected_result: None,
- },
- TestFixture {
- project_id: "p1",
- parent_id: "p2",
- expected_result: Some("p2".to_string()),
- },
- TestFixture {
- project_id: "p1",
- parent_id: "p6",
- expected_result: Some("p6".to_string()),
- },
- TestFixture {
- project_id: "p1",
- parent_id: "p11",
- expected_result: Some("p11".to_string()),
- },
- ];
-
- for test in tests {
- let project_id = test.project_id;
- let parent_id = test.parent_id;
- let expected_result = test.expected_result;
- let result: Option<String> =
- match is_project_recursively_nested(pool.clone(), project_id, parent_id).await {
- Ok(e) => e,
- Err(e) => return Err(e),
- };
-
- assert_eq!(
- (project_id, parent_id, expected_result),
- (project_id, parent_id, result)
- );
- }
-
- Ok(())
- }
-}
diff --git a/crates/macro_db_client/src/projects/preview/mod.rs b/crates/macro_db_client/src/projects/preview/mod.rs
deleted file mode 100644
index 9da575e603..0000000000
--- a/crates/macro_db_client/src/projects/preview/mod.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use std::collections::HashSet;
-
-use model::project::{ProjectPreviewData, ProjectPreviewV2, WithProjectId};
-
-#[tracing::instrument(skip(db))]
-pub async fn batch_get_project_preview_v2(
- db: &sqlx::Pool<sqlx::Postgres>,
- project_ids: &[String],
-) -> anyhow::Result<Vec<ProjectPreviewV2>> {
- let found_documents: Vec<ProjectPreviewData> = sqlx::query_as!(
- ProjectPreviewData,
- r#"
- WITH RECURSIVE project_path AS (
- SELECT
- p.id,
- p.name,
- p."userId",
- p."parentId",
- p."updatedAt",
- ARRAY[p.name] as path
- FROM "Project" p
- WHERE p.id = ANY($1)
-
- UNION ALL
-
- SELECT
- pp.id,
- pp.name,
- pp."userId",
- parent."parentId",
- pp."updatedAt",
- ARRAY[parent.name] || pp.path as path
- FROM project_path pp
- JOIN "Project" parent ON pp."parentId" = parent.id
- )
- SELECT DISTINCT ON (id)
- id as "id!",
- name as "name!",
- "userId" as "owner!",
- path as "path!",
- "updatedAt"::timestamptz as "updated_at"
- FROM project_path
- WHERE "parentId" IS NULL
- ORDER BY id
- "#,
- project_ids,
- )
- .fetch_all(db)
- .await?;
-
- let found_projects: HashSet<String> =
- found_documents.iter().map(|row| row.id.clone()).collect();
-
- let result: Vec<ProjectPreviewV2> = project_ids
- .iter()
- .map(|id| {
- if !found_projects.contains(id) {
- ProjectPreviewV2::DoesNotExist(WithProjectId { id: id.clone() })
- } else {
- let row = found_documents.iter().find(|r| r.id == *id).unwrap();
-
- ProjectPreviewV2::Found(row.clone())
- }
- })
- .collect();
-
- Ok(result)
-}
-
-#[cfg(test)]
-mod test;
diff --git a/crates/macro_db_client/src/projects/preview/test.rs b/crates/macro_db_client/src/projects/preview/test.rs
deleted file mode 100644
index 77fdb1d1e8..0000000000
--- a/crates/macro_db_client/src/projects/preview/test.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use super::*;
-use sqlx::{Pool, Postgres};
-
-#[sqlx::test(fixtures(path = "../../../fixtures", scripts("project_preview")))]
-async fn test_batch_get_project_preview_v2(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let project_ids = vec![
- "project-one".to_string(),
- "project-two".to_string(),
- "non-existent-proj".to_string(),
- ];
-
- let results = batch_get_project_preview_v2(&pool, &project_ids).await?;
-
- assert_eq!(results.len(), 3);
-
- match &results[0] {
- ProjectPreviewV2::Found(data) => {
- assert_eq!(data.id, "project-one");
- assert_eq!(data.name, "test_project_name");
- assert_eq!(data.path, vec!["test_project_name"]);
- }
- _ => panic!("Expected Found variant for project-one"),
- }
-
- match &results[1] {
- ProjectPreviewV2::Found(data) => {
- assert_eq!(data.id, "project-two");
- assert_eq!(data.path, vec!["test_project_name"]);
- }
- _ => panic!("Expected Found variant for project-two"),
- }
-
- match &results[2] {
- ProjectPreviewV2::DoesNotExist(data) => {
- assert_eq!(data.id, "non-existent-proj");
- }
- _ => panic!("Expected DoesNotExist variant for non-existent-proj"),
- }
-
- Ok(())
-}
-
-#[sqlx::test(fixtures(path = "../../../fixtures", scripts("project_preview_nested")))]
-async fn test_batch_get_project_preview_nested(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let project_ids = vec![
- "root-project".to_string(),
- "level1-project".to_string(),
- "level2-project".to_string(),
- "level3-project".to_string(),
- "alt-level1-project".to_string(),
- "standalone-project".to_string(),
- ];
-
- let results = batch_get_project_preview_v2(&pool, &project_ids).await?;
-
- assert_eq!(results.len(), 6);
-
- match &results[0] {
- ProjectPreviewV2::Found(data) => {
- assert_eq!(data.id, "root-project");
- assert_eq!(data.name, "Root Project");
- assert_eq!(data.path, vec!["Root Project"]);
- }
- _ => panic!("Expected Found variant for root-project"),
- }
-
- match &results[1] {
- ProjectPreviewV2::Found(data) => {
- assert_eq!(data.id, "level1-project");
- assert_eq!(data.name, "Level 1");
- assert_eq!(data.path, vec!["Root Project", "Level 1"]);
- }
- _ => panic!("Expected Found variant for level1-project"),
- }
-
- match &results[2] {
- ProjectPreviewV2::Found(data) => {
- assert_eq!(data.id, "level2-project");
- assert_eq!(data.name, "Level 2");
- assert_eq!(data.path, vec!["Root Project", "Level 1", "Level 2"]);
- }
- _ => panic!("Expected Found variant for level2-project"),
- }
-
- match &results[3] {
- ProjectPreviewV2::Found(data) => {
- assert_eq!(data.id, "level3-project");
- assert_eq!(data.name, "Level 3");
- assert_eq!(
- data.path,
- vec!["Root Project", "Level 1", "Level 2", "Level 3"]
- );
- }
- _ => panic!("Expected Found variant for level3-project"),
- }
-
- match &results[4] {
- ProjectPreviewV2::Found(data) => {
- assert_eq!(data.id, "alt-level1-project");
- assert_eq!(data.name, "Alt Branch");
- assert_eq!(data.path, vec!["Root Project", "Alt Branch"]);
- }
- _ => panic!("Expected Found variant for alt-level1-project"),
- }
-
- match &results[5] {
- ProjectPreviewV2::Found(data) => {
- assert_eq!(data.id, "standalone-project");
- assert_eq!(data.name, "Standalone");
- assert_eq!(data.path, vec!["Standalone"]);
- }
- _ => panic!("Expected Found variant for standalone-project"),
- }
-
- Ok(())
-}
diff --git a/crates/macro_db_client/src/projects/revert_delete.rs b/crates/macro_db_client/src/projects/revert_delete.rs
deleted file mode 100644
index 5508f924d2..0000000000
--- a/crates/macro_db_client/src/projects/revert_delete.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-use anyhow::Context;
-
-use crate::projects::get_project::{
- get_project_chats::get_deleted_chats_from_project_ids,
- get_project_documents::get_deleted_documents_from_project_ids,
-};
-
-use super::get_project::get_sub_items::get_all_deleted_sub_project_ids;
-
-/// Reverts a project deletion
-/// Reverts all sub-items of the project as well
-/// Adds all items back to the users history as well
-/// Returns the ids of the projects that were restored
-#[tracing::instrument(skip(db))]
-pub async fn revert_delete_project(
- db: &sqlx::Pool<sqlx::Postgres>,
- project_id: &str,
- project_parent_id: Option<&str>,
-) -> anyhow::Result<Vec<String>> {
- let mut transaction = db.begin().await.context("unable to begin transaction")?;
-
- let project_ids = get_all_deleted_sub_project_ids(&mut transaction, project_id)
- .await
- .context("unable to get all deleted sub project ids")?;
- let (project_ids_vec, project_user_ids_vec): (Vec<String>, Vec<String>) =
- project_ids.into_iter().unzip();
-
- let chat_ids = get_deleted_chats_from_project_ids(db, &project_ids_vec)
- .await
- .context("unable to get deleted chats")?;
- let (chat_ids_vec, chat_user_ids_vec): (Vec<String>, Vec<String>) =
- chat_ids.into_iter().unzip();
-
- let document_ids = get_deleted_documents_from_project_ids(db, &project_ids_vec)
- .await
- .context("unable to get deleted documents")?;
- let (document_ids_vec, document_user_ids_vec): (Vec<String>, Vec<String>) =
- document_ids.into_iter().unzip();
-
- tracing::trace!("reverted deleted chats");
- sqlx::query!(
- r#"
- UPDATE "Chat" SET "deletedAt" = NULL WHERE id = ANY($1);
- "#,
- &chat_ids_vec,
- )
- .execute(&mut *transaction)
- .await
- .context("unable to revert deleted chats")?;
-
- tracing::trace!("set all chats user history");
- sqlx::query!(
- r#"
- INSERT INTO "UserHistory" ("userId", "itemId", "itemType", "createdAt", "updatedAt")
- SELECT u.user_id, u.item_id, 'chat', NOW(), NOW()
- FROM UNNEST($1::text[], $2::text[]) AS u(item_id, user_id)
- ON CONFLICT ("userId", "itemId", "itemType") DO UPDATE
- SET "updatedAt" = NOW();
- "#,
- &chat_ids_vec,
- &chat_user_ids_vec,
- )
- .execute(&mut *transaction)
- .await
- .context("unable to set chats user history")?;
-
- tracing::trace!("reverted deleted documents");
- sqlx::query!(
- r#"
- UPDATE "Document" SET "deletedAt" = NULL WHERE id = ANY($1);
- "#,
- &document_ids_vec,
- )
- .execute(&mut *transaction)
- .await
- .context("unable to revert deleted documents")?;
-
- tracing::trace!("set all documents user history");
- sqlx::query!(
- r#"
- INSERT INTO "UserHistory" ("userId", "itemId", "itemType", "createdAt", "updatedAt")
- SELECT u.user_id, u.item_id, 'document', NOW(), NOW()
- FROM UNNEST($1::text[], $2::text[]) AS u(item_id, user_id)
- ON CONFLICT ("userId", "itemId", "itemType") DO UPDATE
- SET "updatedAt" = NOW();
- "#,
- &document_ids_vec,
- &document_user_ids_vec,
- )
- .execute(&mut *transaction)
- .await
- .context("unable to set documents user history")?;
-
- tracing::trace!("reverted deleted sub-projects");
- sqlx::query!(
- r#"
- UPDATE "Project" SET "deletedAt" = NULL WHERE id = ANY($1);
- "#,
- &project_ids_vec
- )
- .execute(&mut *transaction)
- .await
- .context("unable to revert deleted sub-projects")?;
-
- tracing::trace!("set all projects user history");
- sqlx::query!(
- r#"
- INSERT INTO "UserHistory" ("userId", "itemId", "itemType", "createdAt", "updatedAt")
- SELECT u.user_id, u.item_id, 'project', NOW(), NOW()
- FROM UNNEST($1::text[], $2::text[]) AS u(item_id, user_id)
- ON CONFLICT ("userId", "itemId", "itemType") DO UPDATE
- SET "updatedAt" = NOW();
- "#,
- &project_ids_vec,
- &project_user_ids_vec,
- )
- .execute(&mut *transaction)
- .await
- .context("unable to set projects user history")?;
-
- if let Some(parent_id) = project_parent_id {
- tracing::trace!("project was in nested");
- let is_deleted = sqlx::query!(
- r#"
- SELECT "deletedAt" as deleted_at FROM "Project" WHERE "id" = $1
- "#,
- parent_id
- )
- .map(|row| row.deleted_at)
- .fetch_one(&mut *transaction)
- .await?;
-
- if is_deleted.is_some() {
- tracing::trace!("parent is deleted, removing parent id from project");
-
- sqlx::query!(
- r#"
- UPDATE "Project" SET "parentId" = NULL WHERE "id" = $1
- "#,
- project_id
- )
- .execute(&mut *transaction)
- .await?;
- }
- }
-
- transaction
- .commit()
- .await
- .context("unable to commit transaction")?;
-
- Ok(project_ids_vec)
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use sqlx::{Pool, Postgres};
-
- #[sqlx::test(fixtures(path = "../../fixtures", scripts("revert_project_delete")))]
- async fn test_revert_delete_project(pool: Pool<Postgres>) -> anyhow::Result<()> {
- revert_delete_project(&pool, "p1", None).await?;
-
- let mut history: Vec<(String, String)> = sqlx::query!(
- r#"
- SELECT "itemId" as item_id, "userId" as user_id
- FROM "UserHistory"
- "#,
- )
- .map(|row| (row.item_id, row.user_id))
- .fetch_all(&pool)
- .await?;
-
- history.sort();
-
- assert_eq!(
- history,
- vec![
- ("c1".to_string(), "macro|[email protected]".to_string()),
- ("c2".to_string(), "macro|[email protected]".to_string()),
- ("d1".to_string(), "macro|[email protected]".to_string()),
- ("d2".to_string(), "macro|[email protected]".to_string()),
- ("p1".to_string(), "macro|[email protected]".to_string()),
- ("p2".to_string(), "macro|[email protected]".to_string()),
- ("p3".to_string(), "macro|[email protected]".to_string()),
- ]
- );
-
- Ok(())
- }
-
- #[sqlx::test(fixtures(path = "../../fixtures", scripts("revert_project_delete")))]
- async fn test_revert_delete_project_nested_deleted_parent(
- pool: Pool<Postgres>,
- ) -> anyhow::Result<()> {
- // insert new parent for p1 that is deleted
- sqlx::query!(
- r#"
- INSERT INTO "Project" ("id", "name", "userId", "deletedAt")
- VALUES ('p4', 'd', 'macro|[email protected]', '2019-10-16 00:00:00')
- "#
- )
- .execute(&pool)
- .await?;
-
- // update p1 to have parent p4
- sqlx::query!(
- r#"
- UPDATE "Project" SET "parentId" = 'p4' WHERE "id" = 'p1'
- "#
- )
- .execute(&pool)
- .await?;
-
- revert_delete_project(&pool, "p1", Some("p4")).await?;
-
- let mut history: Vec<(String, String)> = sqlx::query!(
- r#"
- SELECT "itemId" as item_id, "userId" as user_id
- FROM "UserHistory"
- "#,
- )
- .map(|row| (row.item_id, row.user_id))
- .fetch_all(&pool)
- .await?;
-
- history.sort();
-
- assert_eq!(
- history,
- vec![
- ("c1".to_string(), "macro|[email protected]".to_string()),
- ("c2".to_string(), "macro|[email protected]".to_string()),
- ("d1".to_string(), "macro|[email protected]".to_string()),
- ("d2".to_string(), "macro|[email protected]".to_string()),
- ("p1".to_string(), "macro|[email protected]".to_string()),
- ("p2".to_string(), "macro|[email protected]".to_string()),
- ("p3".to_string(), "macro|[email protected]".to_string()),
- ]
- );
-
- let parent_id = sqlx::query!(
- r#"
- SELECT "parentId" as parent_id FROM "Project" WHERE "id" = 'p1'
- "#
- )
- .map(|row| row.parent_id)
- .fetch_one(&pool)
- .await?;
-
- assert!(parent_id.is_none());
-
- Ok(())
- }
-
- #[sqlx::test(fixtures(path = "../../fixtures", scripts("revert_project_delete")))]
- async fn test_revert_delete_project_nested_not_deleted_parent(
- pool: Pool<Postgres>,
- ) -> anyhow::Result<()> {
- // insert new parent for p1 that is deleted
- sqlx::query!(
- r#"
- INSERT INTO "Project" ("id", "name", "userId")
- VALUES ('p4', 'd', 'macro|[email protected]')
- "#
- )
- .execute(&pool)
- .await?;
-
- // update p1 to have parent p4
- sqlx::query!(
- r#"
- UPDATE "Project" SET "parentId" = 'p4' WHERE "id" = 'p1'
- "#
- )
- .execute(&pool)
- .await?;
-
- revert_delete_project(&pool, "p1", Some("p4")).await?;
-
- let mut history: Vec<(String, String)> = sqlx::query!(
- r#"
- SELECT "itemId" as item_id, "userId" as user_id
- FROM "UserHistory"
- "#,
- )
- .map(|row| (row.item_id, row.user_id))
- .fetch_all(&pool)
- .await?;
-
- history.sort();
-
- assert_eq!(
- history,
- vec![
- ("c1".to_string(), "macro|[email protected]".to_string()),
- ("c2".to_string(), "macro|[email protected]".to_string()),
- ("d1".to_string(), "macro|[email protected]".to_string()),
- ("d2".to_string(), "macro|[email protected]".to_string()),
- ("p1".to_string(), "macro|[email protected]".to_string()),
- ("p2".to_string(), "macro|[email protected]".to_string()),
- ("p3".to_string(), "macro|[email protected]".to_string()),
- ]
- );
-
- let parent_id = sqlx::query!(
- r#"
- SELECT "parentId" as parent_id FROM "Project" WHERE "id" = 'p1'
- "#
- )
- .map(|row| row.parent_id)
- .fetch_one(&pool)
- .await?;
-
- assert!(parent_id.is_some());
-
- Ok(())
- }
-}
diff --git a/crates/macro_db_client/src/projects/upload_folder/mod.rs b/crates/macro_db_client/src/projects/upload_folder/mod.rs
deleted file mode 100644
index eb09092181..0000000000
--- a/crates/macro_db_client/src/projects/upload_folder/mod.rs
+++ /dev/null
@@ -1,1368 +0,0 @@
-use std::collections::HashMap;
-
-use super::get_project::get_sub_items::get_all_sub_project_ids;
-use crate::{
- history::add_user_history_for_project_tree, share_permission::create::create_project_permission,
-};
-use async_recursion::async_recursion;
-use macro_user_id::{cowlike::CowLike, user_id::MacroUserIdStr};
-use model::{
- document::{DocumentMetadata, FileType, FileTypeExt},
- folder::{FileSystemNode, FileSystemNodeWithIds, UploadFolderWithIdsResponse},
- project::Project,
-};
-use model_entity::EntityType;
-use models_permissions::share_permission::SharePermissionV2;
-use models_permissions::share_permission::access_level::AccessLevel;
-use sqlx::{Pool, Postgres, Transaction};
-
-/// Given the root folder file system node, this will create all necessary projects/documents
-/// to mimic the folder that a user uploaded. Returns the extended filesystem node with IDs.
-#[tracing::instrument(skip(transaction, root_folder), fields(root_folder=?root_folder))]
-pub async fn upload_folder_with_ids(
- transaction: &mut Transaction<'_, Postgres>,
- user_id: MacroUserIdStr<'static>,
- share_permission: &SharePermissionV2,
- root_folder: &FileSystemNode,
- root_folder_name: &str,
- upload_request_id: &str,
- parent_id: Option<&str>,
-) -> anyhow::Result<UploadFolderWithIdsResponse> {
- // Create root project
- let root_project = create_project(
- transaction,
- user_id.copied(),
- share_permission,
- root_folder_name,
- parent_id.map(|s| s.to_string()),
- upload_request_id,
- )
- .await?;
-
- let mut result_project_ids: Vec<String> = Vec::new();
- let mut result_documents = Vec::new();
-
- result_project_ids.push(root_project.id.clone());
-
- match root_folder {
- FileSystemNode::File(_) => {
- anyhow::bail!("Expected a folder node, found a file")
- }
- FileSystemNode::Folder(folder_content) => {
- let mut extended_content = HashMap::new();
- for (name, node) in folder_content {
- let extended_node = traverse_with_ids(
- transaction,
- node,
- user_id.clone(),
- share_permission,
- name,
- Some((root_project.id.as_str(), root_project.name.as_str())),
- &mut result_project_ids,
- &mut result_documents,
- upload_request_id,
- )
- .await?;
-
- extended_content.insert(name.clone(), extended_node);
- }
-
- let document_ids: Vec<String> = result_documents
- .iter()
- .map(|d| d.document_id.clone())
- .collect();
- let project_ids: Vec<String> = result_project_ids.clone();
-
- let result_node = FileSystemNodeWithIds::Folder {
- content: extended_content,
- project_id: root_project.id,
- };
-
- let result = UploadFolderWithIdsResponse {
- file_system: result_node,
- project_ids: result_project_ids,
- documents: result_documents,
- };
-
- add_user_history_for_project_tree(transaction, user_id, &project_ids, &document_ids)
- .await?;
-
- return Ok(result);
- }
- }
-}
-
-#[async_recursion]
-#[expect(clippy::too_many_arguments, reason = "too annoying to fix")]
-async fn traverse_with_ids(
- transaction: &mut Transaction<'_, Postgres>,
- node: &FileSystemNode,
- user_id: MacroUserIdStr<'static>,
- share_permission: &SharePermissionV2,
- key: &str,
- parent_project: Option<(&str, &str)>, // id, name
- result_project_ids: &mut Vec<String>,
- result_documents: &mut Vec<DocumentMetadata>,
- upload_request_id: &str,
-) -> anyhow::Result<FileSystemNodeWithIds> {
- match node {
- FileSystemNode::File(item) => {
- if let Some((project_id, project_name)) = parent_project {
- let document = crate::document::v2::create::create_document_txn(
- transaction,
- crate::document::v2::create::CreateDocumentArgs {
- id: None,
- sha: item.sha.as_str(),
- document_name: &FileType::clean_document_name(&item.name)
- .unwrap_or_else(|| item.name.clone()),
- user_id,
- file_type: item.file_type,
- project_id: Some(project_id),
- project_name: Some(project_name),
- share_permission,
- skip_history: true,
- email_attachment_id: None,
- created_at: None,
- is_task: false,
- },
- )
- .await?;
-
- // Add document to the documents vector
- result_documents.push(document.clone());
-
- Ok(FileSystemNodeWithIds::File {
- item: item.clone(),
- document_id: document.document_id,
- })
- } else {
- tracing::warn!("No project present for file upload");
- Err(anyhow::anyhow!("No project present for file upload"))
- }
- }
- FileSystemNode::Folder(folder_content) => {
- if let Some((project_id, _)) = parent_project {
- let project = create_project(
- transaction,
- user_id.copied(),
- share_permission,
- key,
- Some(project_id.to_string()),
- upload_request_id,
- )
- .await?;
-
- result_project_ids.push(project.id.clone());
-
- let mut extended_content = HashMap::new();
-
- // Iterate over the folder's content and recurse into each node
- for (name, sub_node) in folder_content {
- let extended_node = traverse_with_ids(
- transaction,
- sub_node,
- user_id.clone(),
- share_permission,
- name,
- Some((project.id.as_str(), project.name.as_str())),
- result_project_ids,
- result_documents,
- upload_request_id,
- )
- .await?;
-
- extended_content.insert(name.clone(), extended_node);
- }
-
- Ok(FileSystemNodeWithIds::Folder {
- content: extended_content,
- project_id: project.id,
- })
- } else {
- tracing::warn!("No project present for folder upload");
- Err(anyhow::anyhow!("No project present for folder upload"))
- }
- }
- }
-}
-
-/// Creates a project for the folder traversal
-async fn create_project(
- transaction: &mut Transaction<'_, Postgres>,
- user_id: MacroUserIdStr<'_>,
- share_permission: &SharePermissionV2,
- name: &str,
- parent_id: Option<String>,
- upload_request_id: &str,
-) -> anyhow::Result<Project> {
- let project = sqlx::query_as!(
- Project,
- r#"
- INSERT INTO "Project" ("name", "userId", "parentId", "createdAt", "updatedAt", "uploadPending", "uploadRequestId")
- VALUES ($1, $2, $3, NOW(), NOW(), TRUE, $4)
- RETURNING id, name, "userId"::text as user_id, "createdAt"::timestamptz as created_at, "deletedAt"::timestamptz as deleted_at,
- "updatedAt"::timestamptz as updated_at, "parentId" as parent_id
- "#,
- name,
- user_id.as_ref(),
- parent_id,
- upload_request_id
- )
- .fetch_one(transaction.as_mut())
- .await?;
-
- // Create share permission
- create_project_permission(transaction, &project.id, share_permission).await?;
-
- entity_access_db_utils::insert_entity_access_row(
- transaction,
- &macro_uuid::string_to_uuid(&project.id).unwrap(),
- EntityType::Project,
- user_id.as_ref(),
- entity_access_db_utils::EntityAccessSourceType::User,
- AccessLevel::Owner,
- )
- .await?;
-
- Ok(project)
-}
-
-/// Recursively marks a project and all its child projects as no longer having uploadPending=true
-/// Returns a list of all project IDs that were marked as uploaded
-pub async fn mark_projects_uploaded(
- db: Pool<Postgres>,
- // TODO: remove user_id from this function, this was used for adding user history
- _user_id: &str,
- root_project_id: &str,
-) -> anyhow::Result<Vec<String>> {
- let mut transaction = db.begin().await?;
-
- // Get all sub-project IDs of the root project (including the root itself)
- let project_ids = get_all_sub_project_ids(&mut transaction, root_project_id).await?;
-
- if project_ids.is_empty() {
- anyhow::bail!("Project not found: {}", root_project_id);
- }
-
- // Update all projects to set uploadPending to false
- sqlx::query!(
- r#"
- UPDATE "Project"
- SET "uploadPending" = false
- WHERE id = ANY($1)
- RETURNING id
- "#,
- &project_ids[..],
- )
- .fetch_all(transaction.as_mut())
- .await?;
-
- transaction.commit().await?;
-
- Ok(project_ids)
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use model::{
- document::FileType,
- folder::{FileSystemNode, FolderItem},
- };
- use models_permissions::share_permission::SharePermissionV2;
- use sqlx::{Pool, Postgres};
- use std::collections::HashMap;
- use uuid::Uuid;
-
- async fn create_test_permission(pool: &Pool<Postgres>) -> anyhow::Result<SharePermissionV2> {
- let macro_user_id = Uuid::new_v4();
-
- // insert macro_user first (foreign key for User.macro_user_id)
- sqlx::query!(
- r#"
- INSERT INTO "macro_user" ("id", "username", "email", "stripe_customer_id")
- VALUES ($1, $2, $3, $4)
- "#,
- macro_user_id,
- "stripe_id"
- )
- .execute(pool)
- .await?;
-
- // insert macro user into user table
- let _user = sqlx::query!(
- r#"
- INSERT INTO "User" ("id", "email", "macro_user_id")
- VALUES ($1, $2, $3)
- RETURNING id
- "#,
- macro_user_id
- )
- .fetch_one(pool)
- .await?;
-
- Ok(SharePermissionV2 {
- is_public: false,
- id: Uuid::new_v4().to_string(),
- public_access_level: None,
- owner: "macro|[email protected]".to_string(),
- channel_share_permissions: None,
- })
- }
-
- /// Create a test folder structure with nested folders and files
- fn create_test_folder_structure() -> (FileSystemNode, String) {
- let root_folder_name = "Root Test Folder";
-
- // Create files for the root folder
- let root_file1 = FolderItem {
- name: "rootFile1".to_string(),
- full_name: "rootFile1.pdf".to_string(),
- file_type: Some(FileType::Pdf),
- sha: "sha123".to_string(),
- relative_path: "/Root Test Folder".to_string(),
- };
-
- let root_file2 = FolderItem {
- name: "rootFile2".to_string(),
- full_name: "rootFile2.docx".to_string(),
- file_type: Some(FileType::Docx),
- sha: "sha456".to_string(),
- relative_path: "/Root Test Folder".to_string(),
- };
-
- // Create a subfolder with its own files
- let subfolder1_file1 = FolderItem {
- name: "subfolder1File1".to_string(),
- full_name: "subfolder1File1.txt".to_string(),
- file_type: Some(FileType::Txt),
- sha: "sha789".to_string(),
- relative_path: "/Root Test Folder/subfolder1".to_string(),
- };
-
- let subfolder1_file2 = FolderItem {
- name: "subfolder1File2".to_string(),
- full_name: "subfolder1File2.pdf".to_string(),
- file_type: Some(FileType::Pdf),
- sha: "sha101".to_string(),
- relative_path: "/Root Test Folder/subfolder1".to_string(),
- };
-
- // Create a sub-subfolder with its own files
- let subsubfolder_file = FolderItem {
- name: "deepNestedFile".to_string(),
- full_name: "deepNestedFile.pdf".to_string(),
- file_type: Some(FileType::Pdf),
- sha: "sha202".to_string(),
- relative_path: "/Root Test Folder/subfolder1/nested".to_string(),
- };
-
- let mut subsubfolder_content = HashMap::new();
- subsubfolder_content.insert(
- "deepNestedFile.pdf".to_string(),
- FileSystemNode::File(subsubfolder_file),
- );
-
- // Create another subfolder with its own content
- let subfolder2_file = FolderItem {
- name: "subfolder2File".to_string(),
- full_name: "subfolder2File.txt".to_string(),
- file_type: Some(FileType::Txt),
- sha: "sha303".to_string(),
- relative_path: "/Root Test Folder/subfolder2".to_string(),
- };
-
- // ... rest of the structure creation remains the same ...
-
- // Build the subfolder 1 structure
- let mut subfolder1_content = HashMap::new();
- subfolder1_content.insert(
- "subfolder1File1.txt".to_string(),
- FileSystemNode::File(subfolder1_file1),
- );
- subfolder1_content.insert(
- "subfolder1File2.pdf".to_string(),
- FileSystemNode::File(subfolder1_file2),
- );
- subfolder1_content.insert(
- "nested".to_string(),
- FileSystemNode::Folder(subsubfolder_content),
- );
-
- // Build the subfolder 2 structure
- let mut subfolder2_content = HashMap::new();
- subfolder2_content.insert(
- "subfolder2File.txt".to_string(),
- FileSystemNode::File(subfolder2_file),
- );
-
- // Build the root folder structure
- let mut root_content = HashMap::new();
- root_content.insert(
- "rootFile1.pdf".to_string(),
- FileSystemNode::File(root_file1),
- );
- root_content.insert(
- "rootFile2.docx".to_string(),
- FileSystemNode::File(root_file2),
- );
- root_content.insert(
- "subfolder1".to_string(),
- FileSystemNode::Folder(subfolder1_content),
- );
- root_content.insert(
- "subfolder2".to_string(),
- FileSystemNode::Folder(subfolder2_content),
- );
-
- (
- FileSystemNode::Folder(root_content),
- root_folder_name.to_string(),
- )
- }
-
- #[sqlx::test]
- async fn test_upload_folder_preserves_structure(pool: Pool<Postgres>) -> anyhow::Result<()> {
- // Create test data
- let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
- let upload_request_id = "upload_request_id";
- let (folder_tree, root_folder_name) = create_test_folder_structure();
- let share_permission = create_test_permission(&pool).await?;
-
- // Start a transaction
- let mut transaction = pool.begin().await?;
-
- // Upload the folder structure
- let UploadFolderWithIdsResponse {
- project_ids,
- documents,
- ..
- } = upload_folder_with_ids(
- &mut transaction,
- user_id,
- &share_permission,
- &folder_tree,
- &root_folder_name,
- upload_request_id,
- None,
- )
- .await?;
-
- // IMPORTANT: Commit the transaction so the changes are visible in the database
- transaction.commit().await?;
-
- // Debug: Check if we have any projects created
- assert!(!project_ids.is_empty(), "No projects were created");
-
- // Print out document information for debugging
- println!("Created documents: {}", documents.len());
- for doc in &documents {
- tracing::info!(
- "Document: {} in project: {:?}",
- doc.document_name,
- doc.project_id
- );
- }
-
- let root_project_id = &project_ids[0];
-
- // Debug query to verify project existence
- let project = sqlx::query!(
- r#"
- SELECT name, id FROM "Project" WHERE id = $1
- "#,
- root_project_id
- )
- .fetch_one(&pool)
- .await?;
-
- println!("Root project: {} with ID: {}", project.name, project.id);
- assert_eq!(
- project.name, root_folder_name,
- "Root project name doesn't match"
- );
-
- // Debug query to list all documents in the project
- let all_docs = sqlx::query!(
- r#"
- SELECT id, name, "projectId" FROM "Document" WHERE "projectId" = $1
- "#,
- root_project_id
- )
- .fetch_all(&pool)
- .await?;
-
- println!(
- "Found {} documents in project {}",
- all_docs.len(),
- root_project_id
- );
- for doc in &all_docs {
- println!("DB Document: {} with ID: {}", doc.name, doc.id);
- }
-
- // Check for each expected document individually with more detailed output
- for doc_name in &["rootFile1", "rootFile2"] {
- let exists = sqlx::query!(
- r#"
- SELECT EXISTS(
- SELECT 1 FROM "Document"
- WHERE "projectId" = $1 AND name = $2
- ) as "exists!"
- "#,
- root_project_id,
- doc_name
- )
- .fetch_one(&pool)
- .await?
- .exists;
-
- assert!(
- exists,
- "Document '{}' not found in database for project {}",
- doc_name, root_project_id
- );
- }
-
- // First verify we can find the child folders by querying them directly
- let child_folders = sqlx::query!(
- r#"
- SELECT id, name, "uploadPending" as upload_pending FROM "Project"
- WHERE "parentId" = $1
- "#,
- root_project_id
- )
- .fetch_all(&pool)
- .await?;
-
- // assert that the child folders are pending upload
- for folder in &child_folders {
- assert!(folder.upload_pending);
- }
-
- println!("Found {} child folders", child_folders.len());
- for folder in &child_folders {
- println!("Child folder: {} with ID: {}", folder.name, folder.id);
- }
-
- // Then verify the expected folders exist
- for folder_name in &["subfolder1", "subfolder2"] {
- let exists = sqlx::query!(
- r#"
- SELECT EXISTS(
- SELECT 1 FROM "Project"
- WHERE "parentId" = $1 AND name = $2
- ) as "exists!"
- "#,
- root_project_id,
- folder_name
- )
- .fetch_one(&pool)
- .await?
- .exists;
-
- assert!(
- exists,
- "Child folder '{}' not found in database under parent {}",
- folder_name, root_project_id
- );
- }
-
- // Now verify the subfolder structure with better diagnostics
- let subfolder1 = sqlx::query!(
- r#"
- SELECT id FROM "Project"
- WHERE "parentId" = $1 AND name = 'subfolder1'
- "#,
- root_project_id
- )
- .fetch_optional(&pool)
- .await?;
-
- if let Some(subfolder) = subfolder1 {
- let subfolder1_id = subfolder.id;
- println!("Found subfolder1 with ID: {}", subfolder1_id);
-
- // Check for nested folder
- let nested_exists = sqlx::query!(
- r#"
- SELECT EXISTS(
- SELECT 1 FROM "Project"
- WHERE "parentId" = $1 AND name = 'nested'
- ) as "exists!"
- "#,
- subfolder1_id
- )
- .fetch_one(&pool)
- .await?
- .exists;
-
- assert!(
- nested_exists,
- "Nested folder 'nested' not found under 'subfolder1'"
- );
-
- // Verify subfolder1 has the correct documents
- let subfolder1_docs = sqlx::query!(
- r#"
- SELECT name FROM "Document" WHERE "projectId" = $1
- "#,
- subfolder1_id
- )
- .fetch_all(&pool)
- .await?;
-
- let doc_names: Vec<String> = subfolder1_docs.into_iter().map(|r| r.name).collect();
- println!("Documents in subfolder1: {:?}", doc_names);
-
- assert!(
- doc_names.contains(&"subfolder1File1".to_string()),
- "subfolder1File1.txt not found"
- );
- assert!(
- doc_names.contains(&"subfolder1File2".to_string()),
- "subfolder1File2.pdf not found"
- );
- } else {
- panic!("Could not find subfolder1 by direct query");
- }
-
- // Verify total numbers
- assert_eq!(
- documents.len(),
- 6,
- "Expected 6 documents, found {}",
- documents.len()
- );
- assert_eq!(
- project_ids.len(),
- 4,
- "Expected 4 projects, found {}",
- project_ids.len()
- );
-
- // Clean up by deleting the data (as the transaction is now committed)
- let mut cleanup_tx = pool.begin().await?;
- for project_id in &project_ids {
- let _ = sqlx::query!(r#"DELETE FROM "Project" WHERE id = $1"#, project_id)
- .execute(&mut *cleanup_tx)
- .await?;
- }
- cleanup_tx.commit().await?;
-
- Ok(())
- }
-
- #[sqlx::test]
- async fn test_upload_empty_folder(pool: Pool<Postgres>) -> anyhow::Result<()> {
- // Create an empty folder
- let root_folder_name = "Empty Root Folder";
- let empty_folder = FileSystemNode::Folder(HashMap::new());
- let upload_request_id = "upload_request_id";
-
- let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
- let share_permission = create_test_permission(&pool).await?;
-
- // Start a transaction
- let mut transaction = pool.begin().await?;
-
- // Upload the empty folder
- let UploadFolderWithIdsResponse {
- project_ids,
- documents,
- ..
- } = upload_folder_with_ids(
- &mut transaction,
- user_id,
- &share_permission,
- &empty_folder,
- &root_folder_name,
- upload_request_id,
- None,
- )
- .await?;
-
- // Commit transaction to make changes visible
- transaction.commit().await?;
-
- // Verify only the root project was created
- assert_eq!(project_ids.len(), 1, "Expected 1 project for empty folder");
- assert_eq!(documents.len(), 0, "Expected 0 documents for empty folder");
-
- // Clean up the created project
- let mut cleanup_tx = pool.begin().await?;
- for project_id in &project_ids {
- let _ = sqlx::query!(r#"DELETE FROM "Project" WHERE id = $1"#, project_id)
- .execute(&mut *cleanup_tx)
- .await?;
- }
- cleanup_tx.commit().await?;
-
- Ok(())
- }
-
- #[sqlx::test]
- async fn test_upload_deep_nested_structure(pool: Pool<Postgres>) -> anyhow::Result<()> {
- // Create a deeply nested folder structure
- let root_folder_name = "Deep Nested Structure";
- let upload_request_id = "upload_request_id";
-
- // Build a nested structure 5 levels deep
- let mut current_folder = HashMap::new();
- let deepest_file = FolderItem {
- name: "deepestFile".to_string(),
- full_name: "deepestFile.pdf".to_string(),
- file_type: Some(FileType::Pdf),
- sha: "sha_deepest".to_string(),
- relative_path: "/Deep Nested Structure/level1/level2/level3/level4/level5".to_string(),
- };
-
- current_folder.insert(
- "deepestFile.pdf".to_string(),
- FileSystemNode::File(deepest_file.clone()),
- );
-
- // Create 5 levels of nesting
- // We'll build the path as we go up the levels
- let folder_path = String::from("/Deep Nested Structure");
- let mut folder_struct = HashMap::new();
-
- for level in (1..=5).rev() {
- let current_path = if level == 5 {
- format!("{}/level1/level2/level3/level4/level5", folder_path)
- } else if level == 4 {
- format!("{}/level1/level2/level3/level4", folder_path)
- } else if level == 3 {
- format!("{}/level1/level2/level3", folder_path)
- } else if level == 2 {
- format!("{}/level1/level2", folder_path)
- } else {
- format!("{}/level1", folder_path)
- };
-
- let level_file = FolderItem {
- name: format!("file_level{}", level),
- full_name: format!("file_level{}.txt", level),
- file_type: Some(FileType::Txt),
- sha: format!("sha_level{}", level),
- relative_path: current_path.clone(),
- };
-
- if level == 5 {
- // Deepest level - rebuild with both files
- let mut deepest_folder = HashMap::new();
- deepest_folder.insert(
- "deepestFile.pdf".to_string(),
- FileSystemNode::File(deepest_file.clone()),
- );
- deepest_folder.insert(
- format!("file_level{}.txt", level),
- FileSystemNode::File(level_file),
- );
- folder_struct = deepest_folder;
- } else {
- // Create the current level and add the previous level as a subfolder
- let mut parent_folder = HashMap::new();
- parent_folder.insert(
- format!("level{}", level + 1),
- FileSystemNode::Folder(folder_struct),
- );
-
- // Add a file at this level too
- parent_folder.insert(
- format!("file_level{}.txt", level),
- FileSystemNode::File(level_file),
- );
-
- folder_struct = parent_folder;
- }
- }
-
- // Root level
- let mut root_content = HashMap::new();
- root_content.insert("level1".to_string(), FileSystemNode::Folder(folder_struct));
-
- // Add a file at the root level
- let root_file = FolderItem {
- name: "root_file".to_string(),
- full_name: "root_file.txt".to_string(),
- file_type: Some(FileType::Txt),
- sha: "sha_root".to_string(),
- relative_path: "/Deep Nested Structure".to_string(),
- };
-
- root_content.insert("root_file.txt".to_string(), FileSystemNode::File(root_file));
-
- let folder_tree = FileSystemNode::Folder(root_content);
- let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
- let share_permission = create_test_permission(&pool).await?;
-
- // Start a transaction
- let mut transaction = pool.begin().await?;
-
- // Upload the folder structure
- let UploadFolderWithIdsResponse {
- project_ids,
- documents,
- ..
- } = upload_folder_with_ids(
- &mut transaction,
- user_id,
- &share_permission,
- &folder_tree,
- &root_folder_name,
- upload_request_id,
- None,
- )
- .await?;
-
- // Commit the transaction so changes are visible
- transaction.commit().await?;
-
- // Debug output for created documents
- println!(
- "Deep structure test - Created documents: {}",
- documents.len()
- );
- for doc in &documents {
- println!(
- "Document: {} in project: {:?}",
- doc.document_name, doc.project_id
- );
- }
-
- // Verify the expected number of projects and documents
- assert_eq!(
- project_ids.len(),
- 6,
- "Expected 6 projects (root + 5 nested levels)"
- );
- assert_eq!(
- documents.len(),
- 7, // Updated from 6 to 7 to account for the root_file.txt we added
- "Expected 7 documents (1 per level + root file + deepest)"
- );
-
- // Check each level document individually with detailed output
- for level in 1..=5 {
- let doc_name = format!("file_level{}", level);
- let document_exists = sqlx::query!(
- r#"
- SELECT EXISTS(
- SELECT 1 FROM "Document"
- WHERE name = $1
- ) as "exists!"
- "#,
- doc_name
- )
- .fetch_one(&pool)
- .await?
- .exists;
-
- assert!(
- document_exists,
- "Document at level {} ('{}') not found",
- level, doc_name
- );
- }
-
- // Verify the deepest file exists
- let deepest_exists = sqlx::query!(
- r#"
- SELECT EXISTS(
- SELECT 1 FROM "Document"
- WHERE name = $1
- ) as "exists!"
- "#,
- "deepestFile"
- )
- .fetch_one(&pool)
- .await?
- .exists;
-
- assert!(deepest_exists, "Deepest document not found");
-
- // Clean up by deleting the data
- let mut cleanup_tx = pool.begin().await?;
- for project_id in &project_ids {
- let _ = sqlx::query!(r#"DELETE FROM "Project" WHERE id = $1"#, project_id)
- .execute(&mut *cleanup_tx)
- .await?;
- }
- cleanup_tx.commit().await?;
-
- Ok(())
- }
-
- #[sqlx::test]
- async fn test_returned_filesystem_structure(pool: Pool<Postgres>) -> anyhow::Result<()> {
- // Create a simple but distinctive folder structure for testing
- let root_folder_name = "Test FileSystem Structure";
- let upload_request_id = "upload_request_id";
-
- // Create a root file
- let root_file = FolderItem {
- name: "root_document".to_string(),
- full_name: "root_document.pdf".to_string(),
- file_type: Some(FileType::Pdf),
- sha: "sha_root_doc".to_string(),
- relative_path: "/Test FileSystem Structure".to_string(),
- };
-
- // Create a subfolder with a file
- let subfolder_file = FolderItem {
- name: "subfolder_document".to_string(),
- full_name: "subfolder_document.txt".to_string(),
- file_type: Some(FileType::Txt),
- sha: "sha_subfolder_doc".to_string(),
- relative_path: "/Test FileSystem Structure/subfolder".to_string(),
- };
-
- // Build the subfolder
- let mut subfolder_content = HashMap::new();
- subfolder_content.insert(
- "subfolder_document.txt".to_string(),
- FileSystemNode::File(subfolder_file),
- );
-
- // Build the root folder
- let mut root_content = HashMap::new();
- root_content.insert(
- "root_document.pdf".to_string(),
- FileSystemNode::File(root_file),
- );
- root_content.insert(
- "subfolder".to_string(),
- FileSystemNode::Folder(subfolder_content),
- );
-
- let folder_tree = FileSystemNode::Folder(root_content);
- let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
- let share_permission = create_test_permission(&pool).await?;
-
- // Start a transaction
- let mut transaction = pool.begin().await?;
-
- // Upload the folder structure
- let UploadFolderWithIdsResponse {
- file_system,
- project_ids,
- documents,
- } = upload_folder_with_ids(
- &mut transaction,
- user_id,
- &share_permission,
- &folder_tree,
- &root_folder_name,
- &upload_request_id,
- None,
- )
- .await?;
-
- // Commit the transaction
- transaction.commit().await?;
-
- // Now verify the returned file_system structure
-
- // 1. First verify it's a folder node (root)
- match &file_system {
- FileSystemNodeWithIds::File { .. } => {
- panic!("Expected root node to be a folder, got a file");
- }
- FileSystemNodeWithIds::Folder {
- content,
- project_id,
- } => {
- // 2. Verify root project ID is present and matches first project ID
- assert_eq!(project_id, &project_ids[0], "Root project ID mismatch");
-
- // 3. Verify we have the expected content (1 file, 1 subfolder)
- assert_eq!(content.len(), 2, "Root folder should have 2 items");
-
- // 4. Check the root document
- let root_doc = content
- .get("root_document.pdf")
- .expect("Root document missing");
- match root_doc {
- FileSystemNodeWithIds::File { item, document_id } => {
- // Verify document ID is in the returned documents list
- let doc = documents
- .iter()
- .find(|d| &d.document_id == document_id)
- .expect("Document ID in file system not found in documents list");
-
- assert_eq!(doc.document_name, "root_document", "Document name mismatch");
- assert_eq!(item.name, "root_document", "Item name mismatch");
- assert_eq!(
- item.relative_path, "/Test FileSystem Structure",
- "Item path mismatch"
- );
- }
- _ => panic!("Expected root document to be a file node"),
- }
-
- // 5. Check the subfolder
- let subfolder = content.get("subfolder").expect("Subfolder missing");
- match subfolder {
- FileSystemNodeWithIds::Folder {
- content: subfolder_content,
- project_id: subfolder_project_id,
- } => {
- // Verify subfolder project ID is in the project IDs list
- assert!(
- project_ids.contains(subfolder_project_id),
- "Subfolder project ID not found in projects list"
- );
-
- // Verify subfolder has one file
- assert_eq!(subfolder_content.len(), 1, "Subfolder should have 1 file");
-
- // Check the subfolder document
- let subfolder_doc = subfolder_content
- .get("subfolder_document.txt")
- .expect("Subfolder document missing");
-
- match subfolder_doc {
- FileSystemNodeWithIds::File { item, document_id } => {
- // Verify document ID is in the returned documents list
- let doc = documents
- .iter()
- .find(|d| &d.document_id == document_id)
- .expect("Subfolder document ID not found in documents list");
-
- assert_eq!(
- doc.document_name, "subfolder_document",
- "Subfolder document name mismatch"
- );
- assert_eq!(
- item.name, "subfolder_document",
- "Subfolder item name mismatch"
- );
- assert_eq!(
- item.relative_path, "/Test FileSystem Structure/subfolder",
- "Subfolder item path mismatch"
- );
- }
- _ => panic!("Expected subfolder document to be a file node"),
- }
- }
- _ => panic!("Expected subfolder to be a folder node"),
- }
- }
- }
-
- // Verify overall counts
- assert_eq!(
- project_ids.len(),
- 2,
- "Expected 2 projects (root + subfolder)"
- );
- assert_eq!(
- documents.len(),
- 2,
- "Expected 2 documents (root file + subfolder file)"
- );
-
- // Clean up by deleting the data
- let mut cleanup_tx = pool.begin().await?;
- for project_id in &project_ids {
- let _ = sqlx::query!(r#"DELETE FROM "Project" WHERE id = $1"#, project_id)
- .execute(&mut *cleanup_tx)
- .await?;
- }
- cleanup_tx.commit().await?;
-
- Ok(())
- }
-
- #[sqlx::test(fixtures(path = "../../../fixtures", scripts("users", "projects")))]
- async fn test_mark_projects_uploaded(pool: Pool<Postgres>) -> anyhow::Result<()> {
- // First, set all test projects to have uploadPending = true
- sqlx::query!(
- r#"
- UPDATE "Project"
- SET "uploadPending" = true
- WHERE id LIKE 'p%'
- "#,
- )
- .execute(&pool)
- .await?;
-
- // Verify the projects are marked as uploadPending
- let pending_before = sqlx::query!(
- r#"
- SELECT COUNT(*) as "count!"
- FROM "Project"
- WHERE "uploadPending" = true AND id LIKE 'p%'
- "#,
- )
- .fetch_one(&pool)
- .await?;
-
- assert!(
- pending_before.count > 0,
- "Test setup failed, no projects marked as pending"
- );
-
- // Test marking the root project and its children as uploaded
- let project_ids = mark_projects_uploaded(pool.clone(), "macro|[email protected]", "p1").await?;
-
- assert_eq!(project_ids.len(), 11, "(sub)folder count should match");
-
- // Verify the projects are no longer marked as uploadPending
- for project_id in &project_ids {
- let project = sqlx::query!(
- r#"
- SELECT "uploadPending"
- FROM "Project"
- WHERE id = $1
- "#,
- project_id
- )
- .fetch_one(&pool)
- .await?;
-
- assert!(
- !project.uploadPending,
- "Project {} should not be pending upload",
- project_id
- );
- }
-
- // Test with a non-existent project ID
- let result =
- mark_projects_uploaded(pool.clone(), "macro|[email protected]", "non_existent").await;
- assert!(
- result.is_err(),
- "Should return error for non-existent project"
- );
-
- Ok(())
- }
-
- #[sqlx::test]
- async fn test_upload_request_id_set_for_root_and_subprojects(
- pool: Pool<Postgres>,
- ) -> anyhow::Result<()> {
- let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
- let upload_request_id = "upload_request_test_id";
- let (folder_tree, root_folder_name) = create_test_folder_structure();
- let share_permission = create_test_permission(&pool).await?;
-
- // Start a transaction
- let mut transaction = pool.begin().await?;
-
- // Upload the folder structure
- let UploadFolderWithIdsResponse { project_ids, .. } = upload_folder_with_ids(
- &mut transaction,
- user_id,
- &share_permission,
- &folder_tree,
- &root_folder_name,
- upload_request_id,
- None,
- )
- .await?;
-
- // Commit transaction
- transaction.commit().await?;
-
- assert!(!project_ids.is_empty(), "No projects were created");
-
- // Check that all projects (root and subfolders) have the correct upload_request_id set
- for project_id in &project_ids {
- let project = sqlx::query!(
- r#"
- SELECT "uploadRequestId"
- FROM "Project"
- WHERE id = $1
- "#,
- project_id
- )
- .fetch_one(&pool)
- .await?;
-
- assert_eq!(
- project.uploadRequestId.as_deref(),
- Some(upload_request_id),
- "Project {} does not have correct upload_request_id set",
- project_id
- );
- }
-
- // Clean up
- let mut cleanup_tx = pool.begin().await?;
- for project_id in &project_ids {
- let _ = sqlx::query!(r#"DELETE FROM "Project" WHERE id = $1"#, project_id)
- .execute(&mut *cleanup_tx)
- .await?;
- }
- cleanup_tx.commit().await?;
-
- Ok(())
- }
-
- #[sqlx::test]
- async fn test_files_and_folders_with_same_name(pool: Pool<Postgres>) -> anyhow::Result<()> {
- // This tests the scenario where you have both a file and folder with identical names
- // Example: "Report.pdf" (file) and "Report" (folder)
-
- let root_folder_name = "Conflicting Names Test";
- let upload_request_id = "conflict_test_123";
- let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
- let share_permission = create_test_permission(&pool).await?;
-
- // Create a file called "Report.pdf"
- let report_file = FolderItem {
- name: "Report".to_string(),
- full_name: "Report.pdf".to_string(),
- file_type: Some(FileType::Pdf),
- sha: "sha_report_file".to_string(),
- relative_path: "/Conflicting Names Test".to_string(),
- };
-
- // Create a folder called "Report" with a file inside
- let report_folder_file = FolderItem {
- name: "contents".to_string(),
- full_name: "contents.txt".to_string(),
- file_type: Some(FileType::Txt),
- sha: "sha_report_folder_contents".to_string(),
- relative_path: "/Conflicting Names Test/Report".to_string(),
- };
-
- // Build the folder structure
- let mut report_folder_content = HashMap::new();
- report_folder_content.insert(
- "contents.txt".to_string(),
- FileSystemNode::File(report_folder_file),
- );
-
- let mut root_content = HashMap::new();
- root_content.insert("Report.pdf".to_string(), FileSystemNode::File(report_file));
- root_content.insert(
- "Report".to_string(),
- FileSystemNode::Folder(report_folder_content),
- );
-
- let folder_tree = FileSystemNode::Folder(root_content);
-
- // Start transaction
- let mut transaction = pool.begin().await?;
-
- // Upload the folder structure
- let UploadFolderWithIdsResponse {
- file_system,
- project_ids,
- documents,
- ..
- } = upload_folder_with_ids(
- &mut transaction,
- user_id,
- &share_permission,
- &folder_tree,
- root_folder_name,
- upload_request_id,
- None,
- )
- .await?;
-
- // Commit the transaction
- transaction.commit().await?;
-
- // Verify the structure was created correctly
- assert_eq!(
- project_ids.len(),
- 2,
- "Expected 2 projects: root folder + Report subfolder"
- );
- assert_eq!(
- documents.len(),
- 2,
- "Expected 2 documents: Report.pdf file + contents.txt inside Report folder"
- );
-
- // Verify the file system structure
- match &file_system {
- FileSystemNodeWithIds::File { .. } => {
- panic!("Expected root to be a folder");
- }
- FileSystemNodeWithIds::Folder { content, .. } => {
- // Should have both "Report.pdf" (file) and "Report" (folder)
- assert_eq!(content.len(), 2, "Root should have 2 items");
-
- // Verify the file exists
- let report_file_node = content
- .get("Report.pdf")
- .expect("Report.pdf file should exist");
- match report_file_node {
- FileSystemNodeWithIds::File { item, document_id } => {
- assert_eq!(item.name, "Report");
- assert_eq!(item.full_name, "Report.pdf");
- assert_eq!(item.file_type, Some(FileType::Pdf));
-
- // Verify document was created
- let doc = documents
- .iter()
- .find(|d| &d.document_id == document_id)
- .expect("Report.pdf document should exist in documents list");
- assert_eq!(doc.document_name, "Report");
- }
- _ => panic!("Report.pdf should be a file node"),
- }
-
- // Verify the folder exists
- let report_folder_node = content.get("Report").expect("Report folder should exist");
- match report_folder_node {
- FileSystemNodeWithIds::Folder {
- content: folder_content,
- project_id,
- } => {
- assert_eq!(folder_content.len(), 1, "Report folder should have 1 file");
-
- // Verify the file inside the folder
- let contents_file = folder_content
- .get("contents.txt")
- .expect("contents.txt should exist in Report folder");
- match contents_file {
- FileSystemNodeWithIds::File { item, document_id } => {
- assert_eq!(item.name, "contents");
- assert_eq!(item.full_name, "contents.txt");
- assert_eq!(item.relative_path, "/Conflicting Names Test/Report");
-
- // Verify document was created
- let doc = documents
- .iter()
- .find(|d| &d.document_id == document_id)
- .expect("contents.txt document should exist");
- assert_eq!(doc.document_name, "contents");
- }
- _ => panic!("contents.txt should be a file node"),
- }
-
- // Verify the folder has a project_id
- assert!(
- project_ids.contains(project_id),
- "Report folder project_id should be in the project list"
- );
- }
- _ => panic!("Report should be a folder node"),
- }
- }
- }
-
- // Clean up
- let mut cleanup_tx = pool.begin().await?;
- for project_id in &project_ids {
- let _ = sqlx::query!(r#"DELETE FROM "Project" WHERE id = $1"#, project_id)
- .execute(&mut *cleanup_tx)
- .await?;
- }
- cleanup_tx.commit().await?;
-
- Ok(())
- }
-}
diff --git a/crates/macro_db_client/src/share_permission/get.rs b/crates/macro_db_client/src/share_permission/get.rs
index 65258d2205..03dcd94892 100644
--- a/crates/macro_db_client/src/share_permission/get.rs
+++ b/crates/macro_db_client/src/share_permission/get.rs
@@ -104,65 +104,6 @@ pub async fn get_share_permission_id(
Ok(share_permission_id)
}
-#[tracing::instrument(skip(db))]
-pub async fn get_project_share_permission(
- db: &sqlx::Pool<sqlx::Postgres>,
- project_id: &str,
-) -> anyhow::Result<SharePermissionV2> {
- let result = sqlx::query!(
- r#"
- SELECT
- sp.id as id,
- sp."isPublic" as is_public,
- sp."publicAccessLevel" as "public_access_level?",
- p."userId" as owner,
- COALESCE(
- json_agg(json_build_object(
- 'channel_id', csp."channel_id",
- 'access_level', csp."access_level"
- )) FILTER (WHERE csp."channel_id" IS NOT NULL),
- '[]'
- ) as "channel_share_permissions?"
- FROM
- "ProjectPermission" pp
- JOIN "SharePermission" sp ON pp."sharePermissionId" = sp.id
- JOIN "Project" p ON pp."projectId" = p.id
- LEFT JOIN "ChannelSharePermission" csp ON csp."share_permission_id" = sp.id
- WHERE
- pp."projectId" = $1
- GROUP BY
- sp.id, p."userId"
- "#,
- project_id,
- )
- .fetch_one(db)
- .await?;
-
- let channel_share_permissions: Option<Vec<ChannelSharePermission>> =
- if let Some(channel_share_permissions) = result.channel_share_permissions {
- let channel_share_permissions: Vec<ChannelSharePermission> =
- serde_json::from_value(channel_share_permissions)?;
- match channel_share_permissions.is_empty() {
- true => None,
- false => Some(channel_share_permissions),
- }
- } else {
- None
- };
-
- let public_access_level: Option<AccessLevel> = result
- .public_access_level
- .map(|s| AccessLevel::from_str(&s).unwrap());
-
- Ok(SharePermissionV2 {
- id: result.id,
- is_public: result.is_public,
- public_access_level,
- owner: result.owner,
- channel_share_permissions,
- })
-}
-
#[tracing::instrument(skip(db))]
pub async fn get_document_share_permission(
db: &sqlx::Pool<sqlx::Postgres>,
@@ -468,39 +409,6 @@ mod tests {
use super::*;
use models_permissions::share_permission::access_level::AccessLevel;
use models_permissions::share_permission::channel_share_permission::ChannelSharePermission;
- #[sqlx::test(fixtures(path = "../../fixtures", scripts("channel_share_permissions")))]
- async fn test_get_project_share_permission(
- pool: sqlx::Pool<sqlx::Postgres>,
- ) -> anyhow::Result<()> {
- let permission = get_project_share_permission(&pool, "p1").await?;
- assert_eq!(permission.id, "sp-p1".to_string());
- assert!(permission.is_public);
- assert_eq!(permission.public_access_level, Some(AccessLevel::Edit));
- assert_eq!(permission.owner, "macro|[email protected]".to_string());
- assert_eq!(
- permission.channel_share_permissions,
- Some(vec![
- ChannelSharePermission {
- channel_id: "c1".to_string(),
- access_level: AccessLevel::View,
- },
- ChannelSharePermission {
- channel_id: "c2".to_string(),
- access_level: AccessLevel::Edit,
- }
- ])
- );
-
- let permission = get_project_share_permission(&pool, "p2").await?;
- assert_eq!(permission.id, "sp-p2".to_string());
- assert!(!permission.is_public);
- assert!(permission.public_access_level.is_none());
- assert_eq!(permission.owner, "macro|[email protected]".to_string());
- assert!(permission.channel_share_permissions.is_none());
-
- Ok(())
- }
-
#[sqlx::test(fixtures(path = "../../fixtures", scripts("channel_share_permissions")))]
async fn test_get_document_share_permission(
pool: sqlx::Pool<sqlx::Postgres>,
diff --git a/crates/macro_middleware/src/cloud_storage/mod.rs b/crates/macro_middleware/src/cloud_storage/mod.rs
index d3bc9f41d0..197387c8ff 100644
--- a/crates/macro_middleware/src/cloud_storage/mod.rs
+++ b/crates/macro_middleware/src/cloud_storage/mod.rs
@@ -1,4 +1,3 @@
pub mod chat;
pub mod document;
-pub mod project;
pub mod thread;
diff --git a/crates/macro_middleware/src/cloud_storage/project/ensure_project_exists.rs b/crates/macro_middleware/src/cloud_storage/project/ensure_project_exists.rs
deleted file mode 100644
index e3d8ab4f97..0000000000
--- a/crates/macro_middleware/src/cloud_storage/project/ensure_project_exists.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use axum::{
- extract::{Path, Request, State},
- http::StatusCode,
- middleware::Next,
- response::Response,
-};
-use serde::Deserialize;
-use sqlx::{PgPool, Pool, Postgres};
-
-use model::project::BasicProject;
-
-use crate::error_handler::error_handler;
-
-#[derive(Deserialize)]
-pub struct Params {
- pub id: String,
-}
-
-/// Finds the requested project and returns the basic project information to be used in the
-/// request context
-#[tracing::instrument(skip(db))]
-async fn get_basic_project(
- db: &Pool<Postgres>,
- project_id: &str,
-) -> Result<BasicProject, (StatusCode, String)> {
- let result: BasicProject =
- macro_db_client::projects::get_project::get_basic_project::get_basic_project(
- db, project_id,
- )
- .await
- .map_err(|e| {
- tracing::error!(error=?e, "failed to get project");
- if e.to_string()
- .contains("no rows returned by a query that expected to return at least one row")
- {
- return (
- StatusCode::NOT_FOUND,
- format!("project with id \"{}\" was not found", project_id),
- );
- }
- (
- StatusCode::INTERNAL_SERVER_ERROR,
- "unknown error occurred".to_string(),
- )
- })?;
-
- Ok(result)
-}
-
-/// Validates the document exists and inserts DocumentBasic into req context
-pub async fn handler(
- State(db): State<PgPool>,
- Path(Params { id }): Path<Params>,
- mut req: Request,
- next: Next,
-) -> Result<Response, Response> {
- let project = get_basic_project(&db, &id)
- .await
- .map_err(|(status_code, msg)| error_handler(&msg, status_code))?;
-
- req.extensions_mut().insert(project);
- Ok(next.run(req).await)
-}
diff --git a/crates/macro_middleware/src/cloud_storage/project/mod.rs b/crates/macro_middleware/src/cloud_storage/project/mod.rs
deleted file mode 100644
index b399781a10..0000000000
--- a/crates/macro_middleware/src/cloud_storage/project/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod ensure_project_exists;
diff --git a/crates/projects/Cargo.toml b/crates/projects/Cargo.toml
new file mode 100644
index 0000000000..bf34df76f7
--- /dev/null
+++ b/crates/projects/Cargo.toml
@@ -0,0 +1,102 @@
+[package]
+edition = "2024"
+name = "projects"
+publish = false
+version = "0.1.0"
+
+[features]
+axum = [
+ "dep:axum",
+ "dep:axum-extra",
+ "dep:macro_authorization",
+ "dep:model-error-response",
+ "dep:utoipa",
+ "entity_access/axum",
+]
+default = ["axum", "inbound", "outbound", "ports", "service"]
+inbound = ["axum", "ports"]
+outbound = [
+ "dep:async-recursion",
+ "dep:aws-sdk-s3",
+ "dep:base64",
+ "dep:document_sub_type",
+ "dep:dynamodb_client",
+ "dep:entity_access_db_utils",
+ "dep:hex",
+ "dep:macro_sha_count_client",
+ "dep:sqlx",
+ "dep:sqs_client",
+ "dep:system_properties",
+ "ports",
+]
+ports = ["dep:tokio"]
+service = [
+ "dep:entity_access_management",
+ "ports",
+]
+
+[dependencies]
+# Core
+anyhow = { workspace = true }
+chrono = { workspace = true }
+futures = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+unicode-segmentation = { workspace = true }
+uuid = { workspace = true }
+
+# Domain models (always included)
+entity_access = { path = "../entity_access" }
+entity_access_management = { path = "../entity_access_management", default-features = false, features = [
+ "outbound",
+ "ports",
+], optional = true }
+macro_aws_config = { path = "../macro_aws_config", features = ["s3"] }
+macro_env_var = { path = "../macro_env_var" }
+macro_user_id = { path = "../macro_user_id" }
+macro_uuid = { path = "../macro_uuid" }
+model = { path = "../model" }
+model-entity = { path = "../model-entity" }
+models_bulk_upload = { path = "../models_bulk_upload" }
+models_permissions = { path = "../models_permissions" }
+s3_key = { path = "../s3_key" }
+
+# Async runtime (for ports)
+tokio = { workspace = true, optional = true }
+
+# Axum dependencies
+axum = { workspace = true, optional = true }
+axum-extra = { workspace = true, optional = true }
+macro_authorization = { path = "../macro_authorization", optional = true, default-features = false, features = [
+ "axum",
+] }
+model-error-response = { path = "../model-error-response", optional = true }
+utoipa = { workspace = true, optional = true }
+
+# Outbound dependencies
+async-recursion = { version = "1.1.1", optional = true }
+aws-sdk-s3 = { workspace = true, optional = true }
+base64 = { workspace = true, optional = true }
+document_sub_type = { path = "../document_sub_type", optional = true }
+dynamodb_client = { path = "../dynamodb_client", optional = true }
+entity_access_db_utils = { path = "../entity_access_db_utils", optional = true }
+hex = { workspace = true, optional = true }
+macro_sha_count_client = { path = "../macro_sha_count_client", optional = true }
+sqlx = { workspace = true, optional = true }
+sqs_client = { path = "../sqs_client", optional = true }
+system_properties = { path = "../system_properties", optional = true }
+workspace-hack = { version = "0.1", path = "../workspace-hack" }
+
+[dev-dependencies]
+dotenvy = { workspace = true }
+http-body-util = { workspace = true }
+macro_db_migrator = { path = "../macro_db_migrator" }
+macro_env = { path = "../macro_env" }
+mockall = { workspace = true }
+model_user = { path = "../model_user" }
+rootcause = { workspace = true }
+serde_json = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+tower = { workspace = true }
diff --git a/crates/projects/fixtures/projects_test_data.sql b/crates/projects/fixtures/projects_test_data.sql
new file mode 100644
index 0000000000..09327061f6
--- /dev/null
+++ b/crates/projects/fixtures/projects_test_data.sql
@@ -0,0 +1,57 @@
+INSERT INTO public."macro_user" (id, username, email, stripe_customer_id)
+VALUES
+ ('a1111111-1111-1111-1111-111111111111', '[email protected]', '[email protected]', 'stripe-owner'),
+ ('a2222222-2222-2222-2222-222222222222', '[email protected]', '[email protected]', 'stripe-viewer');
+
+INSERT INTO public."User" (id, email, "stripeCustomerId", macro_user_id)
+VALUES
+ ('macro|[email protected]', '[email protected]', 'stripe-owner', 'a1111111-1111-1111-1111-111111111111'),
+ ('macro|[email protected]', '[email protected]', 'stripe-viewer', 'a2222222-2222-2222-2222-222222222222');
+
+INSERT INTO public."Project"
+ (id, name, "userId", "parentId", "createdAt", "updatedAt", "deletedAt", "uploadPending", "uploadRequestId")
+VALUES
+ ('10000000-0000-0000-0000-000000000001', 'Root', 'macro|[email protected]', NULL, '2024-01-01', '2024-01-05', NULL, false, NULL),
+ ('10000000-0000-0000-0000-000000000002', 'First child', 'macro|[email protected]', '10000000-0000-0000-0000-000000000001', '2024-01-02', '2024-01-02', NULL, false, NULL),
+ ('10000000-0000-0000-0000-000000000003', 'Grandchild', 'macro|[email protected]', '10000000-0000-0000-0000-000000000002', '2024-01-03', '2024-01-03', NULL, false, NULL),
+ ('10000000-0000-0000-0000-000000000004', 'Deleted child', 'macro|[email protected]', '10000000-0000-0000-0000-000000000001', '2024-01-04', '2024-01-04', '2024-02-01', false, NULL),
+ ('10000000-0000-0000-0000-000000000005', 'Shared history', 'macro|[email protected]', NULL, '2024-01-05', '2024-01-06', NULL, false, NULL),
+ ('10000000-0000-0000-0000-000000000006', 'Owner pending', 'macro|[email protected]', NULL, '2024-01-06', '2024-01-07', NULL, true, 'request-owner'),
+ ('10000000-0000-0000-0000-000000000007', 'Viewer pending', 'macro|[email protected]', NULL, '2024-01-07', '2024-01-08', NULL, true, 'request-viewer'),
+ ('10000000-0000-0000-0000-000000000008', 'Nested pending', 'macro|[email protected]', '10000000-0000-0000-0000-000000000006', '2024-01-08', '2024-01-09', NULL, true, 'request-owner'),
+ ('10000000-0000-0000-0000-000000000009', 'Deleted root', 'macro|[email protected]', NULL, '2024-01-09', '2024-01-10', '2024-02-02', false, NULL);
+
+INSERT INTO public."UserHistory" ("userId", "itemId", "itemType")
+VALUES
+ ('macro|[email protected]', '10000000-0000-0000-0000-000000000001', 'project'),
+ ('macro|[email protected]', '10000000-0000-0000-0000-000000000005', 'project'),
+ ('macro|[email protected]', '10000000-0000-0000-0000-000000000006', 'project'),
+ ('macro|[email protected]', '10000000-0000-0000-0000-000000000009', 'project');
+
+INSERT INTO public."SharePermission" (id, "isPublic", "publicAccessLevel")
+VALUES ('share-root', true, 'edit');
+INSERT INTO public."ProjectPermission" ("projectId", "sharePermissionId")
+VALUES ('10000000-0000-0000-0000-000000000001', 'share-root');
+INSERT INTO public."ChannelSharePermission" (share_permission_id, channel_id, access_level)
+VALUES ('share-root', 'channel-one', 'view');
+
+INSERT INTO public."Document" (id, name, "fileType", owner, "projectId", "createdAt", "updatedAt", "deletedAt")
+VALUES
+ ('20000000-0000-0000-0000-000000000001', 'Document', 'pdf', 'macro|[email protected]', '10000000-0000-0000-0000-000000000001', '2024-01-03', '2024-01-03', NULL),
+ ('20000000-0000-0000-0000-000000000002', 'Deleted document', 'pdf', 'macro|[email protected]', '10000000-0000-0000-0000-000000000001', '2024-01-04', '2024-01-04', '2024-02-01');
+INSERT INTO public."DocumentInstance" ("documentId", "revisionName", sha, "createdAt", "updatedAt")
+VALUES
+ ('20000000-0000-0000-0000-000000000001', 'Document', 'sha-one', '2024-01-03', '2024-01-03'),
+ ('20000000-0000-0000-0000-000000000002', 'Deleted document', 'sha-two', '2024-01-04', '2024-01-04');
+
+INSERT INTO public."Chat" (id, name, "userId", "projectId", "createdAt", "updatedAt", "deletedAt")
+VALUES
+ ('30000000-0000-0000-0000-000000000001', 'Chat', 'macro|[email protected]', '10000000-0000-0000-0000-000000000001', '2024-01-04', '2024-01-04', NULL),
+ ('30000000-0000-0000-0000-000000000002', 'Deleted chat', 'macro|[email protected]', '10000000-0000-0000-0000-000000000001', '2024-01-05', '2024-01-05', '2024-02-01');
+
+INSERT INTO public.entity_access (entity_id, entity_type, source_id, source_type, access_level)
+VALUES
+ ('10000000-0000-0000-0000-000000000001', 'project', 'macro|[email protected]', 'user', 'owner'),
+ ('10000000-0000-0000-0000-000000000001', 'project', 'macro|[email protected]', 'user', 'view'),
+ ('20000000-0000-0000-0000-000000000001', 'document', 'macro|[email protected]', 'user', 'owner'),
+ ('30000000-0000-0000-0000-000000000001', 'chat', 'macro|[email protected]', 'user', 'owner');
diff --git a/crates/projects/justfile b/crates/projects/justfile
new file mode 100644
index 0000000000..887d7477a8
--- /dev/null
+++ b/crates/projects/justfile
@@ -0,0 +1,9 @@
+import '../../tooling/just/database.just'
+
+mod sqlx '../../tooling/just/sqlx.just'
+
+prepare_db:
+ just sqlx::prepare_db {{ DATABASE_URL }}
+
+check:
+ cargo check --all-features
diff --git a/crates/projects/src/domain.rs b/crates/projects/src/domain.rs
new file mode 100644
index 0000000000..6a5d4f077f
--- /dev/null
+++ b/crates/projects/src/domain.rs
@@ -0,0 +1,13 @@
+//! Domain models, ports, and project service definitions.
+
+pub mod models;
+pub mod response;
+
+#[cfg(feature = "ports")]
+pub mod ports;
+
+#[cfg(feature = "service")]
+pub mod service;
+
+#[cfg(feature = "service")]
+pub mod upload;
diff --git a/crates/projects/src/domain/models.rs b/crates/projects/src/domain/models.rs
new file mode 100644
index 0000000000..d9e9bd52bb
--- /dev/null
+++ b/crates/projects/src/domain/models.rs
@@ -0,0 +1,117 @@
+//! Domain-owned project models.
+
+use macro_user_id::user_id::MacroUserIdStr;
+use model::folder::FileSystemNode;
+use model::project::Project;
+use models_permissions::share_permission::{SharePermissionV2, UpdateSharePermissionRequestV2};
+
+/// Arguments for atomically creating a project and its access metadata.
+#[derive(Debug, Clone)]
+pub struct CreateProjectArgs {
+ /// Project owner.
+ pub user_id: String,
+ /// Project name.
+ pub name: String,
+ /// Optional parent project.
+ pub parent_id: Option<String>,
+ /// Initial sharing configuration.
+ pub share_permission: SharePermissionV2,
+}
+
+/// Arguments for editing a project.
+#[derive(Debug, Clone)]
+pub struct EditProjectArgs {
+ /// Project identifier.
+ pub project_id: String,
+ /// Replacement name, or `None` to leave it unchanged.
+ pub name: Option<String>,
+ /// Whether the parent field is part of the update.
+ pub update_parent: bool,
+ /// Replacement parent. `None` clears it when `update_parent` is true.
+ pub parent_id: Option<String>,
+ /// Optional sharing changes.
+ pub share_permission: Option<UpdateSharePermissionRequestV2>,
+}
+
+/// Identifiers affected by a recursive soft deletion.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SoftDeleteResult {
+ /// Deleted projects, including the requested root.
+ pub project_ids: Vec<String>,
+ /// Deleted documents.
+ pub document_ids: Vec<String>,
+ /// Deleted chats.
+ pub chat_ids: Vec<String>,
+}
+
+/// Result of restoring a recursively deleted project tree.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RevertDeleteResult {
+ /// Restored project identifiers.
+ pub project_ids: Vec<String>,
+}
+
+/// Data returned after permanently purging a soft-deleted project tree.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PurgedProjectTree {
+ /// Purged project identifiers, including the requested root.
+ pub project_ids: Vec<String>,
+ /// Purged chat identifiers.
+ pub chat_ids: Vec<String>,
+ /// Purged document identifiers paired with their owner identifiers.
+ pub documents: Vec<(String, String)>,
+ /// Aggregated BOM part counts grouped by SHA.
+ pub bom_shas: Vec<(String, i64)>,
+}
+
+/// Arguments for creating a pending project tree for a folder upload.
+#[derive(Debug)]
+pub struct UploadFolderRepoArgs {
+ /// Owner of every project and document in the tree.
+ pub user_id: MacroUserIdStr<'static>,
+ /// Initial sharing configuration for every created item.
+ pub share_permission: SharePermissionV2,
+ /// Root folder contents to persist.
+ pub root_folder: FileSystemNode,
+ /// Name of the root project.
+ pub root_folder_name: String,
+ /// Lambda-facing bulk-upload request identifier.
+ pub upload_request_id: String,
+ /// Optional parent for the root project.
+ pub parent_id: Option<String>,
+}
+
+/// Result returned by project creation and editing.
+pub type MutatedProject = Project;
+
+/// Errors produced by project operations.
+#[derive(Debug, thiserror::Error)]
+pub enum ProjectError {
+ /// The requested project was not found.
+ #[error("project not found: {0}")]
+ NotFound(String),
+ /// The caller is not authorized to perform the operation.
+ #[error("unauthorized")]
+ Unauthorized,
+ /// The caller is not authorized, with a client-facing explanation.
+ #[error("{0}")]
+ UnauthorizedWithMessage(String),
+ /// The request is invalid.
+ #[error("bad request: {0}")]
+ BadRequest(String),
+ /// The provided project name exceeds the maximum length.
+ #[error("name too long")]
+ NameTooLong {
+ /// Maximum allowed name length, in grapheme clusters.
+ max: usize,
+ },
+ /// A soft-deleted project cannot be modified.
+ #[error("cannot modify deleted project")]
+ CannotModifyDeleted,
+ /// The requested parent would recursively nest the project.
+ #[error("project is recursively nested")]
+ RecursiveNesting,
+ /// An internal operation failed.
+ #[error("{0}")]
+ Internal(#[from] anyhow::Error),
+}
diff --git a/crates/projects/src/domain/ports.rs b/crates/projects/src/domain/ports.rs
new file mode 100644
index 0000000000..bb0b36cc7a
--- /dev/null
+++ b/crates/projects/src/domain/ports.rs
@@ -0,0 +1,349 @@
+//! Port definitions for the projects domain.
+//!
+//! These traits define the contracts implemented by inbound-facing services
+//! and outbound infrastructure adapters.
+
+use std::future::Future;
+
+use entity_access::domain::models::{
+ EditAccessLevel, EntityAccessReceipt, OwnerAccessLevel, ViewAccessLevel,
+};
+use macro_user_id::user_id::MacroUserIdStr;
+use model::document::ContentType;
+use model::folder::{UploadFolderRequest, UploadFolderResponseData, UploadFolderWithIdsResponse};
+use model::item::{Item, ItemWithUserAccessLevel};
+use model::project::request::{CreateProjectRequest, PatchProjectRequestV2};
+use model::project::response::GetProjectResponseData;
+use model::project::{
+ BasicProject, PendingProject, Project, ProjectPreview, ProjectPreviewV2,
+ ProjectWithUploadRequest,
+};
+use models_bulk_upload::{
+ BulkUploadRequest, BulkUploadRequestDocuments, UploadExtractFolderRequest,
+ UploadExtractFolderResponseData,
+};
+use models_permissions::share_permission::SharePermissionV2;
+use models_permissions::share_permission::access_level::AccessLevel;
+use s3_key::BulkUploadStagingKey;
+use uuid::Uuid;
+
+use super::models::{
+ CreateProjectArgs, EditProjectArgs, MutatedProject, ProjectError, PurgedProjectTree,
+ RevertDeleteResult, SoftDeleteResult, UploadFolderRepoArgs,
+};
+
+/// Repository for reading project data from persistent storage.
+///
+/// SQL and transaction details belong in the outbound adapter implementing
+/// this trait.
+#[cfg_attr(test, mockall::automock(type Err = anyhow::Error;))]
+pub trait ProjectRepo: Send + Sync + 'static {
+ /// Error returned by repository operations.
+ type Err: Into<anyhow::Error> + Send + std::fmt::Debug;
+
+ /// Get a basic project row, including soft-deleted projects.
+ fn get_basic_project(
+ &self,
+ project_id: &str,
+ ) -> impl Future<Output = Result<Option<BasicProject>, Self::Err>> + Send;
+
+ /// Get a full, non-deleted project row.
+ fn get_project_by_id(
+ &self,
+ project_id: &str,
+ ) -> impl Future<Output = Result<Option<Project>, Self::Err>> + Send;
+
+ /// List non-deleted, uploaded projects in the user's view history.
+ fn get_projects_for_user(
+ &self,
+ user_id: &str,
+ ) -> impl Future<Output = Result<Vec<Project>, Self::Err>> + Send;
+
+ /// List non-deleted, pending root projects owned by the user.
+ fn get_pending_root_projects(
+ &self,
+ user_id: &str,
+ ) -> impl Future<Output = Result<Vec<ProjectWithUploadRequest>, Self::Err>> + Send;
+
+ /// Get depth-one project, document, and chat children in display order.
+ fn get_project_children(
+ &self,
+ project_id: &str,
+ ) -> impl Future<Output = Result<Vec<Item>, Self::Err>> + Send;
+
+ /// Get the project's share permission configuration.
+ fn get_project_share_permission(
+ &self,
+ project_id: &str,
+ ) -> impl Future<Output = Result<SharePermissionV2, Self::Err>> + Send;
+
+ /// Get previews for the supplied project identifiers.
+ fn batch_get_project_preview(
+ &self,
+ project_ids: &[String],
+ ) -> impl Future<Output = Result<Vec<ProjectPreviewV2>, Self::Err>> + Send;
+
+ /// Atomically create a project and its permission, history, and owner-access rows.
+ fn create_project(
+ &self,
+ args: CreateProjectArgs,
+ ) -> impl Future<Output = Result<MutatedProject, Self::Err>> + Send;
+
+ /// Edit project fields and optional sharing configuration atomically.
+ fn edit_project(
+ &self,
+ args: EditProjectArgs,
+ ) -> impl Future<Output = Result<MutatedProject, Self::Err>> + Send;
+
+ /// Return whether the proposed parent is inside the project's subtree.
+ fn is_project_recursively_nested(
+ &self,
+ project_id: &str,
+ parent_id: &str,
+ ) -> impl Future<Output = Result<bool, Self::Err>> + Send;
+
+ /// Soft-delete a project and all of its active descendants.
+ fn soft_delete_project(
+ &self,
+ project_id: &str,
+ ) -> impl Future<Output = Result<SoftDeleteResult, Self::Err>> + Send;
+
+ /// Permanently purge an already-soft-deleted project subtree and its child data.
+ fn purge_deleted_project_tree(
+ &self,
+ project_id: &str,
+ ) -> impl Future<Output = Result<PurgedProjectTree, Self::Err>> + Send;
+
+ /// Restore a deleted project subtree and the owners' history rows.
+ fn revert_delete_project(
+ &self,
+ project_id: &str,
+ previous_parent_id: Option<String>,
+ ) -> impl Future<Output = Result<RevertDeleteResult, Self::Err>> + Send;
+
+ /// Create and commit a pending project tree with empty documents.
+ fn upload_folder(
+ &self,
+ args: UploadFolderRepoArgs,
+ ) -> impl Future<Output = Result<UploadFolderWithIdsResponse, Self::Err>> + Send;
+
+ /// Delete a committed upload tree as compensation for later failures.
+ fn delete_uploaded_tree(
+ &self,
+ project_ids: &[String],
+ document_ids: &[String],
+ ) -> impl Future<Output = Result<(), Self::Err>> + Send;
+
+ /// Recursively finalize the uploaded state of a project tree.
+ fn mark_projects_uploaded(
+ &self,
+ root_project_id: &str,
+ ) -> impl Future<Output = Result<Vec<String>, Self::Err>> + Send;
+
+ /// Update the project's modified timestamp.
+ fn update_project_modified(
+ &self,
+ project_id: &str,
+ ) -> impl Future<Output = Result<(), Self::Err>> + Send;
+}
+
+/// Port for creating and inspecting bulk-upload requests.
+pub trait BulkUploadRequestPort: Send + Sync + 'static {
+ /// Create a bulk-upload request.
+ fn create_bulk_upload_request(
+ &self,
+ request_id: Uuid,
+ user_id: &str,
+ name: Option<&str>,
+ parent_id: Option<&str>,
+ ) -> impl Future<Output = anyhow::Result<BulkUploadRequest>> + Send;
+
+ /// Get document statuses for a bulk-upload request.
+ fn get_bulk_upload_document_statuses(
+ &self,
+ upload_request_id: &str,
+ ) -> impl Future<Output = anyhow::Result<BulkUploadRequestDocuments>> + Send;
+}
+
+/// Port for generating project-upload destinations.
+pub trait ProjectUploadUrlPort: Send + Sync + 'static {
+ /// Generate a presigned URL for a bulk-upload archive.
+ fn put_upload_zip_staging_presigned_url(
+ &self,
+ key: BulkUploadStagingKey,
+ sha: String,
+ ) -> impl Future<Output = anyhow::Result<String>> + Send;
+
+ /// Generate a presigned URL for document storage.
+ fn put_document_storage_presigned_url(
+ &self,
+ key: String,
+ sha: String,
+ content_type: ContentType,
+ ) -> impl Future<Output = anyhow::Result<String>> + Send;
+
+ /// Generate a presigned URL for DOCX staging.
+ fn put_docx_upload_presigned_url(
+ &self,
+ key: String,
+ sha: String,
+ content_type: ContentType,
+ ) -> impl Future<Output = anyhow::Result<String>> + Send;
+
+ /// Get the document-storage bucket name for internal destinations.
+ fn document_storage_bucket(&self) -> &str;
+
+ /// Get the DOCX-upload bucket name for internal destinations.
+ fn docx_upload_bucket(&self) -> &str;
+}
+
+/// Port for updating persisted content-hash reference counts.
+pub trait ShaCounterPort: Send + Sync + 'static {
+ /// Decrement each SHA reference count by the supplied amount.
+ fn decrement_counts(
+ &self,
+ sha_counts: &[(String, i64)],
+ ) -> impl Future<Output = anyhow::Result<()>> + Send;
+}
+
+/// Port for publishing project search and document-deletion work.
+pub trait ProjectSearchIndexer: Send + Sync + 'static {
+ /// Enqueue projects for indexing.
+ fn upsert_projects(
+ &self,
+ project_ids: Vec<String>,
+ ) -> impl Future<Output = anyhow::Result<()>> + Send;
+
+ /// Remove projects from the search index.
+ fn remove_projects(
+ &self,
+ project_ids: Vec<String>,
+ ) -> impl Future<Output = anyhow::Result<()>> + Send;
+
+ /// Remove chats from the search index.
+ fn remove_chats(
+ &self,
+ chat_ids: Vec<String>,
+ ) -> impl Future<Output = anyhow::Result<()>> + Send;
+
+ /// Remove documents from the search index.
+ fn remove_documents(
+ &self,
+ document_ids: Vec<String>,
+ ) -> impl Future<Output = anyhow::Result<()>> + Send;
+
+ /// Enqueue document deletion work as `(document_id, owner_id)` pairs.
+ fn enqueue_document_deletes(
+ &self,
+ documents: Vec<(String, String)>,
+ ) -> impl Future<Output = anyhow::Result<()>> + Send;
+}
+
+/// Inbound-facing service interface for project operations.
+pub trait ProjectService: Send + Sync + 'static {
+ /// List projects visible through the user's project history.
+ fn list_projects(
+ &self,
+ user_id: MacroUserIdStr<'static>,
+ ) -> impl Future<Output = Result<Vec<Project>, ProjectError>> + Send;
+
+ /// List pending root projects owned by the user.
+ fn list_pending_projects(
+ &self,
+ user_id: MacroUserIdStr<'static>,
+ ) -> impl Future<Output = Result<Vec<PendingProject>, ProjectError>> + Send;
+
+ /// Get project metadata and the caller's access level.
+ fn get_project(
+ &self,
+ receipt: EntityAccessReceipt<ViewAccessLevel>,
+ ) -> impl Future<Output = Result<GetProjectResponseData, ProjectError>> + Send;
+
+ /// Get depth-one project content with caller-specific access attribution.
+ fn get_project_content(
+ &self,
+ receipt: EntityAccessReceipt<ViewAccessLevel>,
+ ) -> impl Future<Output = Result<Vec<ItemWithUserAccessLevel>, ProjectError>> + Send;
+
+ /// Get project share permissions for an owner.
+ fn get_project_permissions(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ ) -> impl Future<Output = Result<SharePermissionV2, ProjectError>> + Send;
+
+ /// Get the caller's access level from a validated receipt.
+ fn get_project_access_level(
+ &self,
+ receipt: EntityAccessReceipt<ViewAccessLevel>,
+ ) -> impl Future<Output = Result<AccessLevel, ProjectError>> + Send;
+
+ /// Create a project, optionally beneath an authorized parent.
+ fn create_project(
+ &self,
+ actor: MacroUserIdStr<'static>,
+ args: CreateProjectRequest,
+ ) -> impl Future<Output = Result<Project, ProjectError>> + Send;
+
+ /// Edit project metadata and sharing settings.
+ fn edit_project(
+ &self,
+ receipt: EntityAccessReceipt<EditAccessLevel>,
+ project: BasicProject,
+ args: PatchProjectRequestV2,
+ ) -> impl Future<Output = Result<(), ProjectError>> + Send;
+
+ /// Soft-delete a project subtree.
+ fn soft_delete_project(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ project: BasicProject,
+ actor_user_id: String,
+ ) -> impl Future<Output = Result<SoftDeleteResult, ProjectError>> + Send;
+
+ /// Permanently purge a soft-deleted project subtree.
+ fn permanently_delete_project(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ ) -> impl Future<Output = Result<(), ProjectError>> + Send;
+
+ /// Restore a soft-deleted project subtree.
+ fn revert_delete_project(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ project: BasicProject,
+ ) -> impl Future<Output = Result<(), ProjectError>> + Send;
+
+ /// Create a pending project tree and its upload destinations.
+ fn upload_folder(
+ &self,
+ actor: MacroUserIdStr<'static>,
+ internal: bool,
+ args: UploadFolderRequest,
+ ) -> impl Future<Output = Result<UploadFolderResponseData, ProjectError>> + Send;
+
+ /// Create a tracked request for extracting an uploaded archive.
+ fn create_upload_extract_request(
+ &self,
+ actor: MacroUserIdStr<'static>,
+ args: UploadExtractFolderRequest,
+ ) -> impl Future<Output = Result<UploadExtractFolderResponseData, ProjectError>> + Send;
+
+ /// Finalize the uploaded state of a project tree.
+ fn mark_projects_uploaded(
+ &self,
+ root_project_id: &str,
+ ) -> impl Future<Output = Result<Vec<String>, ProjectError>> + Send;
+
+ /// Get project previews without applying per-project access filtering.
+ fn get_batch_preview(
+ &self,
+ actor: Option<MacroUserIdStr<'static>>,
+ project_ids: Vec<String>,
+ ) -> impl Future<Output = Result<Vec<ProjectPreview>, ProjectError>> + Send;
+
+ /// Get basic project metadata without performing access checks.
+ fn internal_get_basic_project(
+ &self,
+ project_id: &str,
+ ) -> impl Future<Output = Result<BasicProject, ProjectError>> + Send;
+}
diff --git a/crates/projects/src/domain/response.rs b/crates/projects/src/domain/response.rs
new file mode 100644
index 0000000000..c0fe5bbc0c
--- /dev/null
+++ b/crates/projects/src/domain/response.rs
@@ -0,0 +1,4 @@
+//! Domain-owned project response types.
+//!
+//! Shared project response DTOs remain in [`model::project::response`] so their
+//! established API contracts can be reused without duplication.
diff --git a/crates/projects/src/domain/service.rs b/crates/projects/src/domain/service.rs
new file mode 100644
index 0000000000..16fb86160a
--- /dev/null
+++ b/crates/projects/src/domain/service.rs
@@ -0,0 +1,744 @@
+//! Concrete project service composition.
+
+use std::collections::HashSet;
+
+use entity_access::domain::models::{
+ EditAccessLevel, EntityAccessAuth, EntityAccessReceipt, EntityPermission, EntityType,
+ OwnerAccessLevel, ViewAccessLevel,
+};
+use entity_access_management::domain::ports::EntityAccessManagementService;
+use futures::stream::{FuturesUnordered, StreamExt};
+use macro_user_id::user_id::MacroUserIdStr;
+use model::folder::{UploadFolderRequest, UploadFolderResponseData};
+use model::item::{Item, ItemWithUserAccessLevel};
+use model::project::request::{CreateProjectRequest, PatchProjectRequestV2};
+use model::project::response::GetProjectResponseData;
+use model::project::{
+ BasicProject, PendingProject, Project, ProjectPreview, ProjectPreviewData, ProjectPreviewV2,
+ WithProjectId,
+};
+use models_bulk_upload::{UploadExtractFolderRequest, UploadExtractFolderResponseData};
+use models_permissions::share_permission::SharePermissionV2;
+use models_permissions::share_permission::access_level::AccessLevel;
+use s3_key::BulkUploadStagingKey;
+use unicode_segmentation::UnicodeSegmentation;
+use uuid::Uuid;
+
+use super::models::{
+ CreateProjectArgs, EditProjectArgs, ProjectError, SoftDeleteResult, UploadFolderRepoArgs,
+};
+use super::ports::{
+ BulkUploadRequestPort, ProjectRepo, ProjectSearchIndexer, ProjectService, ProjectUploadUrlPort,
+ ShaCounterPort,
+};
+use super::upload::{build_destination_map, build_root_folder};
+
+#[cfg(test)]
+mod tests;
+
+const MAX_PROJECT_NAME_GRAPHEMES: usize = 100;
+
+/// Concrete project service backed by repository and external-system ports.
+pub struct ProjectServiceImpl<R, U, D, Sha, Eam, Idx>
+where
+ R: ProjectRepo,
+ U: ProjectUploadUrlPort,
+ D: BulkUploadRequestPort,
+ Sha: ShaCounterPort,
+ Eam: EntityAccessManagementService,
+ Idx: ProjectSearchIndexer,
+{
+ /// Project repository.
+ pub repo: R,
+ /// Upload destination provider.
+ pub upload_url_service: U,
+ /// Bulk-upload request provider.
+ pub bulk_upload_service: D,
+ /// Content-hash reference counter.
+ pub sha_counter: Sha,
+ /// Entity-access inheritance manager.
+ pub entity_access_management_service: Eam,
+ /// Search and deletion queue publisher.
+ pub search_indexer: Idx,
+ /// Optional deterministic upload request ID used by local development.
+ pub fixed_upload_request_id: Option<Uuid>,
+}
+
+impl<R, U, D, Sha, Eam, Idx> ProjectServiceImpl<R, U, D, Sha, Eam, Idx>
+where
+ R: ProjectRepo,
+ U: ProjectUploadUrlPort,
+ D: BulkUploadRequestPort,
+ Sha: ShaCounterPort,
+ Eam: EntityAccessManagementService,
+ Idx: ProjectSearchIndexer,
+{
+ /// Create a project service from its repository and external-system ports.
+ #[allow(clippy::too_many_arguments)]
+ pub fn new(
+ repo: R,
+ upload_url_service: U,
+ bulk_upload_service: D,
+ sha_counter: Sha,
+ entity_access_management_service: Eam,
+ search_indexer: Idx,
+ fixed_upload_request_id: Option<Uuid>,
+ ) -> Self {
+ Self {
+ repo,
+ upload_url_service,
+ bulk_upload_service,
+ sha_counter,
+ entity_access_management_service,
+ search_indexer,
+ fixed_upload_request_id,
+ }
+ }
+
+ async fn bump_project_modified(&self, project_id: &str) {
+ let _ = self
+ .repo
+ .update_project_modified(project_id)
+ .await
+ .inspect_err(|error| {
+ tracing::error!(
+ error = ?error,
+ project_id,
+ "unable to update project modified date"
+ );
+ });
+ let _ = self
+ .search_indexer
+ .upsert_projects(vec![project_id.to_string()])
+ .await
+ .inspect_err(|error| {
+ tracing::error!(
+ error = ?error,
+ project_id,
+ "unable to enqueue project search upsert"
+ );
+ });
+ }
+}
+
+impl<R, U, D, Sha, Eam, Idx> ProjectService for ProjectServiceImpl<R, U, D, Sha, Eam, Idx>
+where
+ R: ProjectRepo,
+ U: ProjectUploadUrlPort,
+ D: BulkUploadRequestPort,
+ Sha: ShaCounterPort,
+ Eam: EntityAccessManagementService,
+ Idx: ProjectSearchIndexer,
+{
+ async fn list_projects(
+ &self,
+ user_id: MacroUserIdStr<'static>,
+ ) -> Result<Vec<Project>, ProjectError> {
+ self.repo
+ .get_projects_for_user(user_id.as_ref())
+ .await
+ .map_err(|error| internal_error(error, "unable to list projects"))
+ }
+
+ async fn list_pending_projects(
+ &self,
+ user_id: MacroUserIdStr<'static>,
+ ) -> Result<Vec<PendingProject>, ProjectError> {
+ let pending_projects = self
+ .repo
+ .get_pending_root_projects(user_id.as_ref())
+ .await
+ .map_err(|error| internal_error(error, "unable to list pending projects"))?;
+ let mut pending_futures = FuturesUnordered::new();
+
+ for pending_project in pending_projects {
+ let project = pending_project.project;
+ if project.parent_id.is_some() {
+ tracing::warn!(project_id = %project.id, "skipping non-root pending project");
+ continue;
+ }
+
+ let upload_request_id = pending_project.upload_request_id;
+ pending_futures.push(async move {
+ let Some(upload_request_id) = upload_request_id else {
+ tracing::warn!(project_id = %project.id, "pending project has no upload request");
+ return Some(PendingProject {
+ project,
+ document_statuses: Vec::new(),
+ });
+ };
+
+ let status_result = match self
+ .bulk_upload_service
+ .get_bulk_upload_document_statuses(&upload_request_id)
+ .await
+ {
+ Ok(status_result) => status_result,
+ Err(error) => {
+ tracing::error!(
+ error = ?error,
+ project_id = %project.id,
+ "unable to get pending project document statuses"
+ );
+ return Some(PendingProject {
+ project,
+ document_statuses: Vec::new(),
+ });
+ }
+ };
+
+ if status_result.documents.is_empty() {
+ tracing::warn!(%upload_request_id, "upload request has no documents");
+ } else if status_result.root_project_id != project.id {
+ tracing::error!(
+ %upload_request_id,
+ project_id = %project.id,
+ dynamo_root_project_id = %status_result.root_project_id,
+ "upload request root project ID does not match pending project"
+ );
+ return None;
+ }
+
+ Some(PendingProject {
+ project,
+ document_statuses: status_result.documents,
+ })
+ });
+ }
+
+ let mut projects = Vec::new();
+ while let Some(project) = pending_futures.next().await {
+ if let Some(project) = project {
+ projects.push(project);
+ }
+ }
+ Ok(projects)
+ }
+
+ async fn get_project(
+ &self,
+ receipt: EntityAccessReceipt<ViewAccessLevel>,
+ ) -> Result<GetProjectResponseData, ProjectError> {
+ let project_id = &receipt.entity().entity_id;
+ let project_metadata = self
+ .repo
+ .get_project_by_id(project_id)
+ .await
+ .map_err(|error| internal_error(error, "unable to get project"))?
+ .ok_or_else(|| ProjectError::NotFound(project_id.clone()))?;
+
+ Ok(GetProjectResponseData {
+ project_metadata,
+ user_access_level: receipt_access_level(&receipt)?,
+ })
+ }
+
+ async fn get_project_content(
+ &self,
+ receipt: EntityAccessReceipt<ViewAccessLevel>,
+ ) -> Result<Vec<ItemWithUserAccessLevel>, ProjectError> {
+ let project_access_level = receipt_access_level(&receipt)?;
+ let actor = match receipt.auth() {
+ EntityAccessAuth::Authenticated(user_id) => Some(user_id.as_ref()),
+ _ => None,
+ };
+ let internal = matches!(receipt.auth(), EntityAccessAuth::Internal);
+ let children = self
+ .repo
+ .get_project_children(&receipt.entity().entity_id)
+ .await
+ .map_err(|error| internal_error(error, "unable to get project content"))?;
+
+ Ok(children
+ .into_iter()
+ .map(|item| {
+ let user_access_level = if internal || actor.is_some_and(|actor| owns(&item, actor))
+ {
+ AccessLevel::Owner
+ } else {
+ project_access_level
+ };
+ ItemWithUserAccessLevel {
+ item,
+ user_access_level,
+ }
+ })
+ .collect())
+ }
+
+ async fn get_project_permissions(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ ) -> Result<SharePermissionV2, ProjectError> {
+ self.repo
+ .get_project_share_permission(&receipt.entity().entity_id)
+ .await
+ .map_err(|error| internal_error(error, "unable to get project permissions"))
+ }
+
+ async fn get_project_access_level(
+ &self,
+ receipt: EntityAccessReceipt<ViewAccessLevel>,
+ ) -> Result<AccessLevel, ProjectError> {
+ receipt_access_level(&receipt)
+ }
+
+ async fn create_project(
+ &self,
+ actor: MacroUserIdStr<'static>,
+ args: CreateProjectRequest,
+ ) -> Result<Project, ProjectError> {
+ validate_project_name(&args.name)?;
+
+ let parent_id = args.project_parent_id.map(|id| id.to_string());
+ let project = self
+ .repo
+ .create_project(CreateProjectArgs {
+ user_id: actor.to_string(),
+ name: args.name,
+ parent_id: parent_id.clone(),
+ share_permission: SharePermissionV2::new_project_share_permission(),
+ })
+ .await
+ .map_err(|error| internal_error(error, "unable to create project"))?;
+
+ let entity_id = args
+ .project_parent_id
+ .map(|_| parse_internal_uuid(&project.id, "created project ID"))
+ .transpose()?;
+ let _ = self
+ .search_indexer
+ .upsert_projects(vec![project.id.clone()])
+ .await
+ .inspect_err(|error| {
+ tracing::error!(
+ error = ?error,
+ project_id = %project.id,
+ "unable to enqueue project search upsert"
+ );
+ });
+
+ if let Some((parent_id, entity_id)) = args.project_parent_id.zip(entity_id) {
+ let _ = self
+ .entity_access_management_service
+ .add_entity_to_project(&entity_id, EntityType::Project, &parent_id)
+ .await
+ .inspect_err(|error| {
+ tracing::error!(
+ error = ?error,
+ %entity_id,
+ project_id = %parent_id,
+ "unable to update entity access for project"
+ );
+ });
+ self.bump_project_modified(&parent_id.to_string()).await;
+ }
+
+ Ok(project)
+ }
+
+ async fn edit_project(
+ &self,
+ receipt: EntityAccessReceipt<EditAccessLevel>,
+ project: BasicProject,
+ args: PatchProjectRequestV2,
+ ) -> Result<(), ProjectError> {
+ if project.deleted_at.is_some() {
+ return Err(ProjectError::CannotModifyDeleted);
+ }
+ if let Some(name) = args.name.as_deref() {
+ validate_project_name(name)?;
+ }
+
+ let is_owner = receipt_is_owner(&receipt);
+ if args.project_parent_id.is_some() && !is_owner {
+ return Err(ProjectError::UnauthorizedWithMessage(
+ "you do not have valid permissions to move this item".to_string(),
+ ));
+ }
+ if args.share_permission.is_some() && !is_owner {
+ return Err(ProjectError::UnauthorizedWithMessage(
+ "you do not have valid permission to modify share permissions".to_string(),
+ ));
+ }
+
+ let new_parent_id = args
+ .project_parent_id
+ .as_deref()
+ .filter(|id| !id.is_empty());
+ if new_parent_id == Some(project.id.as_str()) {
+ return Err(ProjectError::BadRequest(
+ "project parent id matches project id".to_string(),
+ ));
+ }
+ if let Some(parent_id) = new_parent_id {
+ parse_request_uuid(parent_id, "project parent ID")?;
+ let recursively_nested = self
+ .repo
+ .is_project_recursively_nested(&project.id, parent_id)
+ .await
+ .map_err(|error| {
+ internal_error(error, "error checking if project is recursively nested")
+ })?;
+ if recursively_nested {
+ return Err(ProjectError::RecursiveNesting);
+ }
+ }
+
+ let project_uuid = parse_internal_uuid(&project.id, "project ID")?;
+ let old_parent_uuid = project
+ .parent_id
+ .as_deref()
+ .map(|id| parse_internal_uuid(id, "stored parent project ID"))
+ .transpose()?;
+ let new_parent_uuid = new_parent_id
+ .map(|id| parse_request_uuid(id, "project parent ID"))
+ .transpose()?;
+
+ self.repo
+ .edit_project(EditProjectArgs {
+ project_id: project.id.clone(),
+ name: args.name,
+ update_parent: args.project_parent_id.is_some(),
+ parent_id: new_parent_id.map(str::to_string),
+ share_permission: args.share_permission,
+ })
+ .await
+ .map_err(|error| internal_error(error, "unable to patch project"))?;
+
+ self.bump_project_modified(&project.id).await;
+ let _ = self
+ .entity_access_management_service
+ .move_project(
+ &project_uuid,
+ old_parent_uuid.as_ref(),
+ new_parent_uuid.as_ref(),
+ )
+ .await
+ .inspect_err(|error| {
+ tracing::error!(
+ error = ?error,
+ project_id = %project.id,
+ "unable to update entity access for project"
+ );
+ });
+ if let Some(parent_id) = project.parent_id.as_deref() {
+ self.bump_project_modified(parent_id).await;
+ }
+ if let Some(parent_id) = new_parent_id {
+ self.bump_project_modified(parent_id).await;
+ }
+
+ Ok(())
+ }
+
+ async fn soft_delete_project(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ project: BasicProject,
+ _actor_user_id: String,
+ ) -> Result<SoftDeleteResult, ProjectError> {
+ let deleted = self
+ .repo
+ .soft_delete_project(&receipt.entity().entity_id)
+ .await
+ .map_err(|error| internal_error(error, "unable to delete project"))?;
+
+ if !deleted.project_ids.is_empty() {
+ let _ = self
+ .search_indexer
+ .remove_projects(deleted.project_ids.clone())
+ .await
+ .inspect_err(|error| {
+ tracing::error!(error = ?error, "unable to enqueue deleted projects for search");
+ });
+ }
+ if let Some(parent_id) = project.parent_id.as_deref() {
+ self.bump_project_modified(parent_id).await;
+ }
+
+ Ok(deleted)
+ }
+
+ async fn permanently_delete_project(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ ) -> Result<(), ProjectError> {
+ let purged = self
+ .repo
+ .purge_deleted_project_tree(&receipt.entity().entity_id)
+ .await
+ .map_err(|error| internal_error(error, "unable to permanently delete project"))?;
+
+ if !purged.bom_shas.is_empty() {
+ self.sha_counter
+ .decrement_counts(&purged.bom_shas)
+ .await
+ .map_err(|error| internal_error(error, "unable to update document references"))?;
+ }
+
+ if !purged.project_ids.is_empty() {
+ let _ = self
+ .search_indexer
+ .remove_projects(purged.project_ids)
+ .await
+ .inspect_err(|error| tracing::error!(error = ?error, "unable to enqueue purged projects for search"));
+ }
+ if !purged.chat_ids.is_empty() {
+ let _ = self
+ .search_indexer
+ .remove_chats(purged.chat_ids)
+ .await
+ .inspect_err(|error| tracing::error!(error = ?error, "unable to enqueue purged chats for search"));
+ }
+ if !purged.documents.is_empty() {
+ let document_ids = purged
+ .documents
+ .iter()
+ .map(|(document_id, _)| document_id.clone())
+ .collect();
+ let _ = self
+ .search_indexer
+ .remove_documents(document_ids)
+ .await
+ .inspect_err(|error| tracing::error!(error = ?error, "unable to enqueue purged documents for search"));
+ let _ = self
+ .search_indexer
+ .enqueue_document_deletes(purged.documents)
+ .await
+ .inspect_err(
+ |error| tracing::error!(error = ?error, "unable to enqueue document deletion"),
+ );
+ }
+
+ Ok(())
+ }
+
+ async fn revert_delete_project(
+ &self,
+ receipt: EntityAccessReceipt<OwnerAccessLevel>,
+ project: BasicProject,
+ ) -> Result<(), ProjectError> {
+ let restored = self
+ .repo
+ .revert_delete_project(&receipt.entity().entity_id, project.parent_id)
+ .await
+ .map_err(|error| internal_error(error, "unable to revert project"))?;
+
+ if !restored.project_ids.is_empty() {
+ let _ = self
+ .search_indexer
+ .upsert_projects(restored.project_ids)
+ .await
+ .inspect_err(|error| {
+ tracing::error!(error = ?error, "unable to enqueue restored projects for search");
+ });
+ }
+ Ok(())
+ }
+
+ async fn upload_folder(
+ &self,
+ actor: MacroUserIdStr<'static>,
+ internal: bool,
+ args: UploadFolderRequest,
+ ) -> Result<UploadFolderResponseData, ProjectError> {
+ let root_folder = build_root_folder(&args.root_folder_name, args.content)
+ .map_err(|error| internal_error(error, "unable to prepare folder upload"))?;
+ let uploaded = self
+ .repo
+ .upload_folder(UploadFolderRepoArgs {
+ user_id: actor,
+ share_permission: SharePermissionV2::new_project_share_permission(),
+ root_folder,
+ root_folder_name: args.root_folder_name,
+ upload_request_id: args.upload_request_id,
+ parent_id: args.parent_id,
+ })
+ .await
+ .map_err(|error| internal_error(error, "unable to upload folder"))?;
+
+ let document_ids: Vec<String> = uploaded
+ .documents
+ .iter()
+ .map(|document| document.document_id.clone())
+ .collect();
+ let destination_map =
+ match build_destination_map(&self.upload_url_service, &uploaded.documents, internal)
+ .await
+ {
+ Ok(destination_map) => destination_map,
+ Err(error) => {
+ tracing::error!(error = ?error, "unable to build upload destinations");
+ let _ = self
+ .repo
+ .delete_uploaded_tree(&uploaded.project_ids, &document_ids)
+ .await
+ .inspect_err(|compensation_error| {
+ tracing::error!(
+ error = ?compensation_error,
+ "unable to compensate failed folder upload"
+ );
+ });
+ return Err(ProjectError::Internal(anyhow::anyhow!(
+ "unable to prepare folder upload"
+ )));
+ }
+ };
+
+ if !uploaded.project_ids.is_empty() {
+ let _ = self
+ .search_indexer
+ .upsert_projects(uploaded.project_ids)
+ .await
+ .inspect_err(|error| {
+ tracing::error!(error = ?error, "unable to enqueue uploaded projects for search");
+ });
+ }
+
+ Ok(UploadFolderResponseData {
+ file_system: uploaded.file_system,
+ destination_map,
+ })
+ }
+
+ async fn create_upload_extract_request(
+ &self,
+ actor: MacroUserIdStr<'static>,
+ args: UploadExtractFolderRequest,
+ ) -> Result<UploadExtractFolderResponseData, ProjectError> {
+ let request_id = self.fixed_upload_request_id.unwrap_or_else(Uuid::new_v4);
+ let request = self
+ .bulk_upload_service
+ .create_bulk_upload_request(
+ request_id,
+ actor.as_ref(),
+ args.name.as_deref(),
+ args.parent_id.as_deref(),
+ )
+ .await
+ .map_err(|error| internal_error(error, "unable to create upload request"))?;
+ let key = BulkUploadStagingKey::from_s3_key(&request.key)
+ .map_err(|error| internal_error(error, "unable to create upload request"))?;
+ let presigned_url = self
+ .upload_url_service
+ .put_upload_zip_staging_presigned_url(key, args.sha)
+ .await
+ .map_err(|error| internal_error(error, "unable to create upload URL"))?;
+
+ Ok(UploadExtractFolderResponseData {
+ request_id: request_id.to_string(),
+ presigned_url,
+ })
+ }
+
+ async fn mark_projects_uploaded(
+ &self,
+ root_project_id: &str,
+ ) -> Result<Vec<String>, ProjectError> {
+ self.repo
+ .mark_projects_uploaded(root_project_id)
+ .await
+ .map_err(|error| internal_error(error, "unable to mark projects uploaded"))
+ }
+
+ async fn get_batch_preview(
+ &self,
+ _actor: Option<MacroUserIdStr<'static>>,
+ project_ids: Vec<String>,
+ ) -> Result<Vec<ProjectPreview>, ProjectError> {
+ let unique_project_ids: HashSet<String> = project_ids.into_iter().collect();
+ let project_ids: Vec<String> = unique_project_ids.into_iter().collect();
+ let previews = self
+ .repo
+ .batch_get_project_preview(&project_ids)
+ .await
+ .map_err(|error| internal_error(error, "unable to get project previews"))?;
+
+ Ok(previews.into_iter().map(map_preview).collect())
+ }
+
+ async fn internal_get_basic_project(
+ &self,
+ project_id: &str,
+ ) -> Result<BasicProject, ProjectError> {
+ self.repo
+ .get_basic_project(project_id)
+ .await
+ .map_err(|error| internal_error(error, "unable to get basic project"))?
+ .ok_or_else(|| ProjectError::NotFound(project_id.to_string()))
+ }
+}
+
+fn validate_project_name(name: &str) -> Result<(), ProjectError> {
+ if name.graphemes(true).count() > MAX_PROJECT_NAME_GRAPHEMES {
+ return Err(ProjectError::NameTooLong {
+ max: MAX_PROJECT_NAME_GRAPHEMES,
+ });
+ }
+ Ok(())
+}
+
+fn receipt_is_owner(receipt: &EntityAccessReceipt<EditAccessLevel>) -> bool {
+ matches!(
+ receipt.entity_permission(),
+ EntityPermission::AccessLevel {
+ access_level: AccessLevel::Owner
+ }
+ )
+}
+
+fn parse_request_uuid(value: &str, field: &str) -> Result<Uuid, ProjectError> {
+ Uuid::parse_str(value)
+ .map_err(|_| ProjectError::BadRequest(format!("{field} must be a valid UUID")))
+}
+
+fn parse_internal_uuid(value: &str, field: &str) -> Result<Uuid, ProjectError> {
+ Uuid::parse_str(value).map_err(|error| {
+ ProjectError::Internal(anyhow::anyhow!("invalid {field} in project data: {error}"))
+ })
+}
+
+fn receipt_access_level<T>(receipt: &EntityAccessReceipt<T>) -> Result<AccessLevel, ProjectError>
+where
+ T: entity_access::domain::models::RequiredPermission,
+{
+ if matches!(receipt.auth(), EntityAccessAuth::Internal) {
+ return Ok(AccessLevel::Owner);
+ }
+
+ match receipt.entity_permission() {
+ EntityPermission::AccessLevel { access_level } => Ok(*access_level),
+ _ => Err(ProjectError::Internal(anyhow::anyhow!(
+ "invalid project access receipt"
+ ))),
+ }
+}
+
+fn owns(item: &Item, actor: &str) -> bool {
+ match item {
+ Item::Project(project) => project.user_id == actor,
+ Item::Document(document) => document.owner.as_ref() == actor,
+ Item::Chat(chat) => chat.user_id == actor,
+ }
+}
+
+fn map_preview(preview: ProjectPreviewV2) -> ProjectPreview {
+ match preview {
+ ProjectPreviewV2::Found(data) => ProjectPreview::Access(ProjectPreviewData {
+ id: data.id,
+ name: data.name,
+ owner: data.owner,
+ path: data.path,
+ updated_at: data.updated_at,
+ }),
+ ProjectPreviewV2::DoesNotExist(data) => {
+ ProjectPreview::DoesNotExist(WithProjectId { id: data.id })
+ }
+ }
+}
+
+fn internal_error(error: impl std::fmt::Debug, message: &'static str) -> ProjectError {
+ tracing::error!(error = ?error, message);
+ ProjectError::Internal(anyhow::anyhow!(message))
+}
diff --git a/crates/projects/src/domain/service/tests.rs b/crates/projects/src/domain/service/tests.rs
new file mode 100644
index 0000000000..ae62ebac47
--- /dev/null
+++ b/crates/projects/src/domain/service/tests.rs
@@ -0,0 +1,1268 @@
+use std::sync::{Arc, Mutex};
+
+use entity_access::domain::models::{
+ EditAccessLevel, Entity, EntityAccessAuth, EntityAccessReceipt, EntityPermission, EntityType,
+ OwnerAccessLevel, ViewAccessLevel,
+};
+use entity_access_management::domain::models::EntityAccessManagementError;
+use entity_access_management::domain::ports::EntityAccessManagementService;
+use macro_user_id::user_id::MacroUserIdStr;
+use model::document::{ContentType, DocumentMetadata, FileType};
+use model::folder::{
+ FileSystemNodeWithIds, FolderItem, S3Destination, UploadFolderRequest,
+ UploadFolderWithIdsResponse,
+};
+use model::item::Item;
+use model::project::request::{CreateProjectRequest, PatchProjectRequestV2};
+use model::project::{
+ BasicProject, Project, ProjectPreviewData, ProjectPreviewV2, ProjectWithUploadRequest,
+};
+use models_bulk_upload::{
+ BulkUploadRequest, BulkUploadRequestDocuments, ProjectDocumentStatus, UploadDocumentStatus,
+ UploadExtractFolderRequest, UploadFolderStatus,
+};
+use models_permissions::share_permission::UpdateSharePermissionRequestV2;
+use models_permissions::share_permission::access_level::AccessLevel;
+use s3_key::BulkUploadStagingKey;
+use uuid::Uuid;
+
+use super::*;
+use crate::domain::models::PurgedProjectTree;
+use crate::domain::ports::MockProjectRepo;
+
+#[derive(Clone, Copy)]
+struct NullPort;
+
+impl ProjectUploadUrlPort for NullPort {
+ async fn put_upload_zip_staging_presigned_url(
+ &self,
+ _key: BulkUploadStagingKey,
+ _sha: String,
+ ) -> anyhow::Result<String> {
+ unreachable!()
+ }
+
+ async fn put_document_storage_presigned_url(
+ &self,
+ _key: String,
+ _sha: String,
+ _content_type: ContentType,
+ ) -> anyhow::Result<String> {
+ unreachable!()
+ }
+
+ async fn put_docx_upload_presigned_url(
+ &self,
+ _key: String,
+ _sha: String,
+ _content_type: ContentType,
+ ) -> anyhow::Result<String> {
+ unreachable!()
+ }
+
+ fn document_storage_bucket(&self) -> &str {
+ "unused"
+ }
+
+ fn docx_upload_bucket(&self) -> &str {
+ "unused"
+ }
+}
+
+impl ShaCounterPort for NullPort {
+ async fn decrement_counts(&self, _sha_counts: &[(String, i64)]) -> anyhow::Result<()> {
+ unreachable!()
+ }
+}
+
+impl EntityAccessManagementService for NullPort {
+ async fn add_entity_to_project(
+ &self,
+ _entity_id: &Uuid,
+ _entity_type: EntityType,
+ _project_id: &Uuid,
+ ) -> Result<(), EntityAccessManagementError> {
+ unreachable!()
+ }
+
+ async fn remove_entity_from_project(
+ &self,
+ _entity_id: &Uuid,
+ _entity_type: EntityType,
+ _old_project_id: &Uuid,
+ ) -> Result<(), EntityAccessManagementError> {
+ unreachable!()
+ }
+
+ async fn move_project(
+ &self,
+ _project_id: &Uuid,
+ _old_project_id: Option<&Uuid>,
+ _new_project_id: Option<&Uuid>,
+ ) -> Result<(), EntityAccessManagementError> {
+ unreachable!()
+ }
+}
+
+impl ProjectSearchIndexer for NullPort {
+ async fn upsert_projects(&self, _project_ids: Vec<String>) -> anyhow::Result<()> {
+ unreachable!()
+ }
+
+ async fn remove_projects(&self, _project_ids: Vec<String>) -> anyhow::Result<()> {
+ unreachable!()
+ }
+
+ async fn remove_chats(&self, _chat_ids: Vec<String>) -> anyhow::Result<()> {
+ unreachable!()
+ }
+
+ async fn remove_documents(&self, _document_ids: Vec<String>) -> anyhow::Result<()> {
+ unreachable!()
+ }
+
+ async fn enqueue_document_deletes(
+ &self,
+ _documents: Vec<(String, String)>,
+ ) -> anyhow::Result<()> {
+ unreachable!()
+ }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum EamCall {
+ Add(Uuid, Uuid),
+ Move(Uuid, Option<Uuid>, Option<Uuid>),
+}
+
+#[derive(Clone, Default)]
+struct RecordingEam {
+ calls: Arc<Mutex<Vec<EamCall>>>,
+}
+
+impl EntityAccessManagementService for RecordingEam {
+ async fn add_entity_to_project(
+ &self,
+ entity_id: &Uuid,
+ _entity_type: EntityType,
+ project_id: &Uuid,
+ ) -> Result<(), EntityAccessManagementError> {
+ self.calls
+ .lock()
+ .unwrap()
+ .push(EamCall::Add(*entity_id, *project_id));
+ Ok(())
+ }
+
+ async fn remove_entity_from_project(
+ &self,
+ _entity_id: &Uuid,
+ _entity_type: EntityType,
+ _old_project_id: &Uuid,
+ ) -> Result<(), EntityAccessManagementError> {
+ unreachable!()
+ }
+
+ async fn move_project(
+ &self,
+ project_id: &Uuid,
+ old_project_id: Option<&Uuid>,
+ new_project_id: Option<&Uuid>,
+ ) -> Result<(), EntityAccessManagementError> {
+ self.calls.lock().unwrap().push(EamCall::Move(
+ *project_id,
+ old_project_id.copied(),
+ new_project_id.copied(),
+ ));
+ Ok(())
+ }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum IndexCall {
+ Upsert(Vec<String>),
+ Remove(Vec<String>),
+}
+
+#[derive(Clone, Default)]
+struct RecordingIndexer {
+ calls: Arc<Mutex<Vec<IndexCall>>>,
+}
+
+impl ProjectSearchIndexer for RecordingIndexer {
+ async fn upsert_projects(&self, project_ids: Vec<String>) -> anyhow::Result<()> {
+ self.calls
+ .lock()
+ .unwrap()
+ .push(IndexCall::Upsert(project_ids));
+ Ok(())
+ }
+
+ async fn remove_projects(&self, project_ids: Vec<String>) -> anyhow::Result<()> {
+ self.calls
+ .lock()
+ .unwrap()
+ .push(IndexCall::Remove(project_ids));
+ Ok(())
+ }
+
+ async fn remove_chats(&self, _chat_ids: Vec<String>) -> anyhow::Result<()> {
+ unreachable!()
+ }
+
+ async fn remove_documents(&self, _document_ids: Vec<String>) -> anyhow::Result<()> {
+ unreachable!()
+ }
+
+ async fn enqueue_document_deletes(
+ &self,
+ _documents: Vec<(String, String)>,
+ ) -> anyhow::Result<()> {
+ unreachable!()
+ }
+}
+
+fn mutation_service(
+ repo: MockProjectRepo,
+ eam: RecordingEam,
+ indexer: RecordingIndexer,
+) -> ProjectServiceImpl<
+ MockProjectRepo,
+ NullPort,
+ RecordingBulkUpload,
+ NullPort,
+ RecordingEam,
+ RecordingIndexer,
+> {
+ ProjectServiceImpl::new(
+ repo,
+ NullPort,
+ RecordingBulkUpload::default(),
+ NullPort,
+ eam,
+ indexer,
+ None,
+ )
+}
+
+#[derive(Clone, Default)]
+struct RecordingBulkUpload {
+ calls: Arc<Mutex<Vec<String>>>,
+}
+
+impl BulkUploadRequestPort for RecordingBulkUpload {
+ async fn create_bulk_upload_request(
+ &self,
+ _request_id: Uuid,
+ _user_id: &str,
+ _name: Option<&str>,
+ _parent_id: Option<&str>,
+ ) -> anyhow::Result<BulkUploadRequest> {
+ unreachable!()
+ }
+
+ async fn get_bulk_upload_document_statuses(
+ &self,
+ upload_request_id: &str,
+ ) -> anyhow::Result<BulkUploadRequestDocuments> {
+ self.calls
+ .lock()
+ .unwrap()
+ .push(upload_request_id.to_string());
+ match upload_request_id {
+ "failed" => anyhow::bail!("sensitive dynamo failure"),
+ "mismatch" => Ok(BulkUploadRequestDocuments {
+ root_project_id: "another-project".to_string(),
+ documents: vec![document_status()],
+ }),
+ _ => Ok(BulkUploadRequestDocuments {
+ root_project_id: upload_request_id.to_string(),
+ documents: vec![document_status()],
+ }),
+ }
+ }
+}
+
+fn service<D: BulkUploadRequestPort>(
+ repo: MockProjectRepo,
+ bulk_upload_service: D,
+) -> ProjectServiceImpl<MockProjectRepo, NullPort, D, NullPort, NullPort, NullPort> {
+ ProjectServiceImpl::new(
+ repo,
+ NullPort,
+ bulk_upload_service,
+ NullPort,
+ NullPort,
+ NullPort,
+ None,
+ )
+}
+
+fn user_id(value: &str) -> MacroUserIdStr<'static> {
+ MacroUserIdStr::try_from(value.to_string()).unwrap()
+}
+
+fn project(id: &str, owner: &str, parent_id: Option<&str>) -> Project {
+ Project {
+ id: id.to_string(),
+ name: id.to_string(),
+ user_id: owner.to_string(),
+ parent_id: parent_id.map(str::to_string),
+ created_at: None,
+ updated_at: None,
+ deleted_at: None,
+ }
+}
+
+fn receipt(
+ auth: EntityAccessAuth,
+ access_level: AccessLevel,
+) -> EntityAccessReceipt<ViewAccessLevel> {
+ EntityAccessReceipt::try_new(
+ auth,
+ Entity {
+ entity_id: "root".to_string(),
+ entity_type: EntityType::Project,
+ },
+ EntityPermission::AccessLevel { access_level },
+ )
+ .unwrap()
+}
+
+fn basic_project(id: Uuid, parent_id: Option<Uuid>, deleted: bool) -> BasicProject {
+ BasicProject {
+ id: id.to_string(),
+ user_id: user_id("macro|[email protected]"),
+ parent_id: parent_id.map(|id| id.to_string()),
+ name: "Project".to_string(),
+ deleted_at: deleted.then(chrono::Utc::now),
+ }
+}
+
+fn mutation_receipt<T>(project_id: Uuid, access_level: AccessLevel) -> EntityAccessReceipt<T>
+where
+ T: entity_access::domain::models::RequiredPermission,
+{
+ EntityAccessReceipt::try_new(
+ EntityAccessAuth::Authenticated(user_id("macro|[email protected]")),
+ Entity {
+ entity_id: project_id.to_string(),
+ entity_type: EntityType::Project,
+ },
+ EntityPermission::AccessLevel { access_level },
+ )
+ .unwrap()
+}
+
+fn patch_request(
+ parent_id: Option<String>,
+ share_permission: Option<UpdateSharePermissionRequestV2>,
+) -> PatchProjectRequestV2 {
+ PatchProjectRequestV2 {
+ name: None,
+ project_parent_id: parent_id,
+ share_permission,
+ }
+}
+
+fn share_update() -> UpdateSharePermissionRequestV2 {
+ UpdateSharePermissionRequestV2 {
+ is_public: Some(true),
+ public_access_level: Some(AccessLevel::View),
+ channel_share_permissions: None,
+ }
+}
+
+fn document_status() -> ProjectDocumentStatus {
+ ProjectDocumentStatus {
+ document_id: "document".to_string(),
+ status: UploadDocumentStatus::Pending,
+ }
+}
+
+#[tokio::test]
+async fn content_attributes_owner_access_to_owned_items() {
+ let mut repo = MockProjectRepo::new();
+ repo.expect_get_project_children().return_once(|_| {
+ Box::pin(async {
+ Ok(vec![
+ Item::Project(project("owned", "macro|[email protected]", Some("root"))),
+ Item::Project(project("shared", "macro|[email protected]", Some("root"))),
+ ])
+ })
+ });
+ let service = service(repo, RecordingBulkUpload::default());
+
+ let content = service
+ .get_project_content(receipt(
+ EntityAccessAuth::Authenticated(user_id("macro|[email protected]")),
+ AccessLevel::Edit,
+ ))
+ .await
+ .unwrap();
+
+ assert_eq!(content[0].user_access_level, AccessLevel::Owner);
+ assert_eq!(content[1].user_access_level, AccessLevel::Edit);
+}
+
+#[tokio::test]
+async fn content_attributes_owner_access_to_every_item_for_internal_receipts() {
+ let mut repo = MockProjectRepo::new();
+ repo.expect_get_project_children().return_once(|_| {
+ Box::pin(async {
+ Ok(vec![Item::Project(project(
+ "shared",
+ Some("root"),
+ ))])
+ })
+ });
+ let service = service(repo, RecordingBulkUpload::default());
+
+ let content = service
+ .get_project_content(receipt(EntityAccessAuth::Internal, AccessLevel::View))
+ .await
+ .unwrap();
+
+ assert_eq!(content[0].user_access_level, AccessLevel::Owner);
+}
+
+#[tokio::test]
+async fn pending_projects_isolate_status_failures_and_root_mismatches() {
+ let mut repo = MockProjectRepo::new();
+ repo.expect_get_pending_root_projects().return_once(|_| {
+ Box::pin(async {
+ Ok(vec![
+ ProjectWithUploadRequest {
+ project: project("failed", "owner", None),
+ upload_request_id: Some("failed".to_string()),
+ },
+ ProjectWithUploadRequest {
+ project: project("mismatch", "owner", None),
+ upload_request_id: Some("mismatch".to_string()),
+ },
+ ProjectWithUploadRequest {
+ project: project("nested", "owner", Some("root")),
+ upload_request_id: Some("nested".to_string()),
+ },
+ ProjectWithUploadRequest {
+ project: project("without-request", "owner", None),
+ upload_request_id: None,
+ },
+ ])
+ })
+ });
+ let bulk_upload = RecordingBulkUpload::default();
+ let calls = bulk_upload.calls.clone();
+ let service = service(repo, bulk_upload);
+
+ let pending = service
+ .list_pending_projects(user_id("macro|[email protected]"))
+ .await
+ .unwrap();
+
+ assert_eq!(pending.len(), 2);
+ assert!(
+ pending
+ .iter()
+ .all(|project| project.document_statuses.is_empty())
+ );
+ assert!(pending.iter().any(|project| project.project.id == "failed"));
+ assert!(
+ pending
+ .iter()
+ .any(|project| project.project.id == "without-request")
+ );
+ let mut calls = calls.lock().unwrap().clone();
+ calls.sort();
+ assert_eq!(calls, vec!["failed", "mismatch"]);
+}
+
+#[tokio::test]
+async fn preview_deduplicates_ids_before_calling_repository() {
+ let mut repo = MockProjectRepo::new();
+ repo.expect_batch_get_project_preview()
+ .withf(|ids| {
+ ids.len() == 2 && ids.iter().any(|id| id == "one") && ids.iter().any(|id| id == "two")
+ })
+ .return_once(|_| {
+ Box::pin(async {
+ Ok(vec![ProjectPreviewV2::Found(ProjectPreviewData {
+ id: "one".to_string(),
+ name: "One".to_string(),
+ owner: "owner".to_string(),
+ path: Vec::new(),
+ updated_at: None,
+ })])
+ })
+ });
+ let service = service(repo, RecordingBulkUpload::default());
+
+ let previews = service
+ .get_batch_preview(
+ Some(user_id("macro|[email protected]")),
+ vec!["one".to_string(), "two".to_string(), "one".to_string()],
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(previews.len(), 1);
+ assert!(matches!(&previews[0], ProjectPreview::Access(data) if data.id == "one"));
+}
+
+#[tokio::test]
+async fn create_uses_grapheme_limit_and_orchestrates_parent_side_effects() {
+ let project_id = Uuid::new_v4();
+ let parent_id = Uuid::new_v4();
+ let accepted_name = "👨‍👩‍👧‍👦".repeat(100);
+ let expected_name = accepted_name.clone();
+ let mut repo = MockProjectRepo::new();
+ repo.expect_create_project()
+ .withf(move |args| {
+ args.name == expected_name
+ && args.parent_id.as_deref() == Some(parent_id.to_string().as_str())
+ && !args.share_permission.is_public
+ })
+ .return_once(move |_| {
+ Box::pin(async move {
+ Ok(project(
+ &project_id.to_string(),
+ Some(&parent_id.to_string()),
+ ))
+ })
+ });
+ repo.expect_update_project_modified()
+ .withf(move |id| id == parent_id.to_string())
+ .return_once(|_| Box::pin(async { Ok(()) }));
+ let eam = RecordingEam::default();
+ let eam_calls = eam.calls.clone();
+ let indexer = RecordingIndexer::default();
+ let index_calls = indexer.calls.clone();
+ let service = mutation_service(repo, eam, indexer);
+
+ service
+ .create_project(
+ user_id("macro|[email protected]"),
+ CreateProjectRequest {
+ name: accepted_name,
+ project_parent_id: Some(parent_id),
+ },
+ )
+ .await
+ .unwrap();
+ let error = service
+ .create_project(
+ user_id("macro|[email protected]"),
+ CreateProjectRequest {
+ name: "👨‍👩‍👧‍👦".repeat(101),
+ project_parent_id: None,
+ },
+ )
+ .await
+ .unwrap_err();
+
+ assert!(matches!(error, ProjectError::NameTooLong { max: 100 }));
+ assert_eq!(
+ *eam_calls.lock().unwrap(),
+ vec![EamCall::Add(project_id, parent_id)]
+ );
+ assert_eq!(
+ *index_calls.lock().unwrap(),
+ vec![
+ IndexCall::Upsert(vec![project_id.to_string()]),
+ IndexCall::Upsert(vec![parent_id.to_string()]),
+ ]
+ );
+}
+
+#[tokio::test]
+async fn edit_requires_owner_for_moves_and_share_changes() {
+ let project_id = Uuid::new_v4();
+ let parent_id = Uuid::new_v4();
+ let repo = MockProjectRepo::new();
+ let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());
+
+ let move_error = service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
+ basic_project(project_id, None, false),
+ patch_request(Some(parent_id.to_string()), None),
+ )
+ .await
+ .unwrap_err();
+ let share_error = service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
+ basic_project(project_id, None, false),
+ patch_request(None, Some(share_update())),
+ )
+ .await
+ .unwrap_err();
+
+ assert!(matches!(
+ move_error,
+ ProjectError::UnauthorizedWithMessage(_)
+ ));
+ assert!(matches!(
+ share_error,
+ ProjectError::UnauthorizedWithMessage(_)
+ ));
+}
+
+#[tokio::test]
+async fn edit_rejects_deleted_self_recursive_and_invalid_parents() {
+ let project_id = Uuid::new_v4();
+ let recursive_parent = Uuid::new_v4();
+ let mut repo = MockProjectRepo::new();
+ repo.expect_is_project_recursively_nested()
+ .withf(move |id, parent| {
+ id == project_id.to_string() && parent == recursive_parent.to_string()
+ })
+ .return_once(|_, _| Box::pin(async { Ok(true) }));
+ let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());
+
+ let deleted = service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
+ basic_project(project_id, None, true),
+ patch_request(None, None),
+ )
+ .await
+ .unwrap_err();
+ let self_parent = service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
+ basic_project(project_id, None, false),
+ patch_request(Some(project_id.to_string()), None),
+ )
+ .await
+ .unwrap_err();
+ let invalid_parent = service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
+ basic_project(project_id, None, false),
+ patch_request(Some("not-a-uuid".to_string()), None),
+ )
+ .await
+ .unwrap_err();
+ let recursive = service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
+ basic_project(project_id, None, false),
+ patch_request(Some(recursive_parent.to_string()), None),
+ )
+ .await
+ .unwrap_err();
+
+ assert!(matches!(deleted, ProjectError::CannotModifyDeleted));
+ assert!(matches!(self_parent, ProjectError::BadRequest(_)));
+ assert!(matches!(invalid_parent, ProjectError::BadRequest(_)));
+ assert!(matches!(recursive, ProjectError::RecursiveNesting));
+}
+
+#[tokio::test]
+async fn owner_edit_propagates_move_and_pairs_every_bump_with_an_upsert() {
+ let project_id = Uuid::new_v4();
+ let old_parent_id = Uuid::new_v4();
+ let new_parent_id = Uuid::new_v4();
+ let bumped = Arc::new(Mutex::new(Vec::new()));
+ let recorded_bumps = bumped.clone();
+ let mut repo = MockProjectRepo::new();
+ repo.expect_is_project_recursively_nested()
+ .return_once(|_, _| Box::pin(async { Ok(false) }));
+ repo.expect_edit_project()
+ .withf(move |args| {
+ args.project_id == project_id.to_string()
+ && args.update_parent
+ && args.parent_id.as_deref() == Some(new_parent_id.to_string().as_str())
+ })
+ .return_once(move |_| {
+ Box::pin(async move {
+ Ok(project(
+ &project_id.to_string(),
+ Some(&new_parent_id.to_string()),
+ ))
+ })
+ });
+ repo.expect_update_project_modified()
+ .times(3)
+ .returning(move |id| {
+ recorded_bumps.lock().unwrap().push(id.to_string());
+ Box::pin(async { Ok(()) })
+ });
+ let eam = RecordingEam::default();
+ let eam_calls = eam.calls.clone();
+ let indexer = RecordingIndexer::default();
+ let index_calls = indexer.calls.clone();
+ let service = mutation_service(repo, eam, indexer);
+
+ service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
+ basic_project(project_id, Some(old_parent_id), false),
+ patch_request(Some(new_parent_id.to_string()), Some(share_update())),
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(
+ *eam_calls.lock().unwrap(),
+ vec![EamCall::Move(
+ project_id,
+ Some(old_parent_id),
+ Some(new_parent_id)
+ )]
+ );
+ let bumps = bumped.lock().unwrap().clone();
+ let indexed = index_calls
+ .lock()
+ .unwrap()
+ .iter()
+ .filter_map(|call| match call {
+ IndexCall::Upsert(ids) if ids.len() == 1 => Some(ids[0].clone()),
+ _ => None,
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(bumps, indexed);
+}
+
+#[tokio::test]
+async fn empty_parent_clears_persistence_and_eam_parent_argument() {
+ let project_id = Uuid::new_v4();
+ let old_parent_id = Uuid::new_v4();
+ let mut repo = MockProjectRepo::new();
+ repo.expect_edit_project()
+ .withf(|args| args.update_parent && args.parent_id.is_none())
+ .return_once(move |_| {
+ Box::pin(async move {
+ Ok(project(
+ &project_id.to_string(),
+ None,
+ ))
+ })
+ });
+ repo.expect_update_project_modified()
+ .times(2)
+ .returning(|_| Box::pin(async { Ok(()) }));
+ let eam = RecordingEam::default();
+ let calls = eam.calls.clone();
+ let service = mutation_service(repo, eam, RecordingIndexer::default());
+
+ service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
+ basic_project(project_id, Some(old_parent_id), false),
+ patch_request(Some(String::new()), None),
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(
+ *calls.lock().unwrap(),
+ vec![EamCall::Move(project_id, Some(old_parent_id), None)]
+ );
+}
+
+#[tokio::test]
+async fn edit_name_limit_counts_unicode_graphemes() {
+ let project_id = Uuid::new_v4();
+ let mut repo = MockProjectRepo::new();
+ repo.expect_edit_project().return_once(move |_| {
+ Box::pin(async move {
+ Ok(project(
+ &project_id.to_string(),
+ None,
+ ))
+ })
+ });
+ repo.expect_update_project_modified()
+ .return_once(|_| Box::pin(async { Ok(()) }));
+ let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());
+ let mut accepted = patch_request(None, None);
+ accepted.name = Some("é".repeat(100));
+
+ service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
+ basic_project(project_id, None, false),
+ accepted,
+ )
+ .await
+ .unwrap();
+ let mut rejected = patch_request(None, None);
+ rejected.name = Some("é".repeat(101));
+ let error = service
+ .edit_project(
+ mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
+ basic_project(project_id, None, false),
+ rejected,
+ )
+ .await
+ .unwrap_err();
+
+ assert!(matches!(error, ProjectError::NameTooLong { max: 100 }));
+}
+
+#[tokio::test]
+async fn failed_database_bump_still_runs_the_paired_index_upsert() {
+ let project_id = Uuid::new_v4();
+ let mut repo = MockProjectRepo::new();
+ repo.expect_update_project_modified()
+ .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("database unavailable")) }));
+ let indexer = RecordingIndexer::default();
+ let calls = indexer.calls.clone();
+ let service = mutation_service(repo, RecordingEam::default(), indexer);
+
+ service.bump_project_modified(&project_id.to_string()).await;
+
+ assert_eq!(
+ *calls.lock().unwrap(),
+ vec![IndexCall::Upsert(vec![project_id.to_string()])]
+ );
+}
+
+#[tokio::test]
+async fn soft_delete_removes_index_entries_and_bumps_parent_with_upsert() {
+ let project_id = Uuid::new_v4();
+ let parent_id = Uuid::new_v4();
+ let deleted_ids = vec![project_id.to_string(), Uuid::new_v4().to_string()];
+ let expected_deleted_ids = deleted_ids.clone();
+ let mut repo = MockProjectRepo::new();
+ repo.expect_soft_delete_project().return_once(move |_| {
+ Box::pin(async move {
+ Ok(SoftDeleteResult {
+ project_ids: deleted_ids,
+ document_ids: vec!["document".to_string()],
+ chat_ids: vec!["chat".to_string()],
+ })
+ })
+ });
+ repo.expect_update_project_modified()
+ .withf(move |id| id == parent_id.to_string())
+ .return_once(|_| Box::pin(async { Ok(()) }));
+ let indexer = RecordingIndexer::default();
+ let calls = indexer.calls.clone();
+ let service = mutation_service(repo, RecordingEam::default(), indexer);
+
+ service
+ .soft_delete_project(
+ mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),
+ basic_project(project_id, Some(parent_id), false),
+ "macro|[email protected]".to_string(),
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(
+ *calls.lock().unwrap(),
+ vec![
+ IndexCall::Remove(expected_deleted_ids),
+ IndexCall::Upsert(vec![parent_id.to_string()]),
+ ]
+ );
+}
+
+#[tokio::test]
+async fn revert_upserts_every_restored_project() {
+ let project_id = Uuid::new_v4();
+ let parent_id = Uuid::new_v4();
+ let restored_ids = vec![project_id.to_string(), Uuid::new_v4().to_string()];
+ let expected_ids = restored_ids.clone();
+ let mut repo = MockProjectRepo::new();
+ repo.expect_revert_delete_project()
+ .withf(move |id, parent| {
+ id == project_id.to_string()
+ && parent.as_deref() == Some(parent_id.to_string().as_str())
+ })
+ .return_once(move |_, _| {
+ Box::pin(async move {
+ Ok(crate::domain::models::RevertDeleteResult {
+ project_ids: restored_ids,
+ })
+ })
+ });
+ let indexer = RecordingIndexer::default();
+ let calls = indexer.calls.clone();
+ let service = mutation_service(repo, RecordingEam::default(), indexer);
+
+ service
+ .revert_delete_project(
+ mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),
+ basic_project(project_id, Some(parent_id), true),
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(
+ *calls.lock().unwrap(),
+ vec![IndexCall::Upsert(expected_ids)]
+ );
+}
+
+#[tokio::test]
+async fn missing_full_project_maps_to_not_found() {
+ let mut repo = MockProjectRepo::new();
+ repo.expect_get_project_by_id()
+ .return_once(|_| Box::pin(async { Ok(None) }));
+ let service = service(repo, RecordingBulkUpload::default());
+
+ let error = service
+ .get_project(receipt(
+ EntityAccessAuth::Authenticated(user_id("macro|[email protected]")),
+ AccessLevel::View,
+ ))
+ .await
+ .unwrap_err();
+
+ assert!(matches!(error, ProjectError::NotFound(id) if id == "root"));
+}
+
+#[derive(Clone)]
+struct OrderedSha {
+ events: Arc<Mutex<Vec<&'static str>>>,
+}
+
+impl ShaCounterPort for OrderedSha {
+ async fn decrement_counts(&self, _sha_counts: &[(String, i64)]) -> anyhow::Result<()> {
+ self.events.lock().unwrap().push("sha");
+ Ok(())
+ }
+}
+
+#[derive(Clone)]
+struct OrderedIndexer {
+ events: Arc<Mutex<Vec<&'static str>>>,
+ fail: bool,
+}
+
+impl OrderedIndexer {
+ fn record(&self, event: &'static str) -> anyhow::Result<()> {
+ self.events.lock().unwrap().push(event);
+ if self.fail {
+ anyhow::bail!("index unavailable");
+ }
+ Ok(())
+ }
+}
+
+impl ProjectSearchIndexer for OrderedIndexer {
+ async fn upsert_projects(&self, _project_ids: Vec<String>) -> anyhow::Result<()> {
+ self.record("upsert")
+ }
+
+ async fn remove_projects(&self, _project_ids: Vec<String>) -> anyhow::Result<()> {
+ self.record("projects")
+ }
+
+ async fn remove_chats(&self, _chat_ids: Vec<String>) -> anyhow::Result<()> {
+ self.record("chats")
+ }
+
+ async fn remove_documents(&self, _document_ids: Vec<String>) -> anyhow::Result<()> {
+ self.record("documents")
+ }
+
+ async fn enqueue_document_deletes(
+ &self,
+ _documents: Vec<(String, String)>,
+ ) -> anyhow::Result<()> {
+ self.record("document_deletes")
+ }
+}
+
+#[derive(Clone)]
+struct RecordingUploadUrls {
+ calls: Arc<Mutex<Vec<String>>>,
+ fail_document: bool,
+}
+
+impl ProjectUploadUrlPort for RecordingUploadUrls {
+ async fn put_upload_zip_staging_presigned_url(
+ &self,
+ key: BulkUploadStagingKey,
+ _sha: String,
+ ) -> anyhow::Result<String> {
+ self.calls.lock().unwrap().push(key.to_key());
+ Ok("https://upload.example".to_string())
+ }
+
+ async fn put_document_storage_presigned_url(
+ &self,
+ key: String,
+ _sha: String,
+ _content_type: ContentType,
+ ) -> anyhow::Result<String> {
+ self.calls.lock().unwrap().push(key);
+ if self.fail_document {
+ anyhow::bail!("sensitive S3 failure");
+ }
+ Ok("https://document.example".to_string())
+ }
+
+ async fn put_docx_upload_presigned_url(
+ &self,
+ _key: String,
+ _sha: String,
+ _content_type: ContentType,
+ ) -> anyhow::Result<String> {
+ unreachable!()
+ }
+
+ fn document_storage_bucket(&self) -> &str {
+ "documents-bucket"
+ }
+
+ fn docx_upload_bucket(&self) -> &str {
+ "docx-bucket"
+ }
+}
+
+#[derive(Clone)]
+struct RecordingExtract {
+ request_ids: Arc<Mutex<Vec<Uuid>>>,
+}
+
+impl BulkUploadRequestPort for RecordingExtract {
+ async fn create_bulk_upload_request(
+ &self,
+ request_id: Uuid,
+ user_id: &str,
+ name: Option<&str>,
+ parent_id: Option<&str>,
+ ) -> anyhow::Result<BulkUploadRequest> {
+ self.request_ids.lock().unwrap().push(request_id);
+ Ok(BulkUploadRequest {
+ request_id: request_id.to_string(),
+ user_id: user_id.to_string(),
+ key: format!("extract/{request_id}"),
+ status: UploadFolderStatus::Pending,
+ name: name.map(str::to_string),
+ created_at: String::new(),
+ updated_at: String::new(),
+ completed_at: None,
+ error_message: None,
+ root_project_id: None,
+ parent_id: parent_id.map(str::to_string),
+ })
+ }
+
+ async fn get_bulk_upload_document_statuses(
+ &self,
+ _upload_request_id: &str,
+ ) -> anyhow::Result<BulkUploadRequestDocuments> {
+ unreachable!()
+ }
+}
+
+fn upload_document(id: &str, file_type: FileType) -> DocumentMetadata {
+ DocumentMetadata::new_document(
+ id,
+ 7,
+ user_id("macro|[email protected]"),
+ id,
+ Some(file_type),
+ "0123456789abcdef",
+ None,
+ None,
+ None,
+ Some("project"),
+ Some("Project"),
+ None,
+ None,
+ None,
+ )
+}
+
+#[tokio::test]
+async fn permanent_delete_runs_external_work_after_committed_purge() {
+ let events = Arc::new(Mutex::new(Vec::new()));
+ let repo_events = events.clone();
+ let mut repo = MockProjectRepo::new();
+ repo.expect_purge_deleted_project_tree()
+ .return_once(move |_| {
+ repo_events.lock().unwrap().push("repo");
+ Box::pin(async {
+ Ok(PurgedProjectTree {
+ project_ids: vec!["project".to_string()],
+ chat_ids: vec!["chat".to_string()],
+ documents: vec![("document".to_string(), "owner".to_string())],
+ bom_shas: vec![("sha".to_string(), 2)],
+ })
+ })
+ });
+ let service = ProjectServiceImpl::new(
+ repo,
+ NullPort,
+ RecordingBulkUpload::default(),
+ OrderedSha {
+ events: events.clone(),
+ },
+ NullPort,
+ OrderedIndexer {
+ events: events.clone(),
+ fail: true,
+ },
+ None,
+ );
+
+ service
+ .permanently_delete_project(mutation_receipt::<OwnerAccessLevel>(
+ Uuid::new_v4(),
+ AccessLevel::Owner,
+ ))
+ .await
+ .unwrap();
+
+ assert_eq!(
+ *events.lock().unwrap(),
+ vec![
+ "repo",
+ "sha",
+ "projects",
+ "chats",
+ "documents",
+ "document_deletes"
+ ]
+ );
+}
+
+#[tokio::test]
+async fn permanent_delete_has_no_external_side_effects_when_purge_fails() {
+ let mut repo = MockProjectRepo::new();
+ repo.expect_purge_deleted_project_tree()
+ .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("commit failed")) }));
+ let service = service(repo, RecordingBulkUpload::default());
+
+ let result = service
+ .permanently_delete_project(mutation_receipt::<OwnerAccessLevel>(
+ Uuid::new_v4(),
+ AccessLevel::Owner,
+ ))
+ .await;
+
+ assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn destination_maps_preserve_internal_external_and_docx_behavior() {
+ let urls = RecordingUploadUrls {
+ calls: Arc::new(Mutex::new(Vec::new())),
+ fail_document: false,
+ };
+ let pdf = upload_document("pdf", FileType::Pdf);
+ let docx = upload_document("docx", FileType::Docx);
+
+ let internal = build_destination_map(&urls, &[pdf.clone(), docx.clone()], true)
+ .await
+ .unwrap();
+ assert!(matches!(
+ internal.get("pdf"),
+ Some(S3Destination::Internal(info)) if info.bucket == "documents-bucket"
+ ));
+ assert!(matches!(
+ internal.get("docx"),
+ Some(S3Destination::Internal(info)) if info.bucket == "docx-bucket"
+ ));
+
+ let external = build_destination_map(&urls, &[pdf, docx], false)
+ .await
+ .unwrap();
+ assert!(matches!(
+ external.get("pdf"),
+ Some(S3Destination::External(_))
+ ));
+ assert!(!external.contains_key("docx"));
+}
+
+#[tokio::test]
+async fn upload_folder_compensates_after_destination_failure() {
+ let mut repo = MockProjectRepo::new();
+ repo.expect_upload_folder().return_once(|_| {
+ Box::pin(async {
+ Ok(UploadFolderWithIdsResponse {
+ file_system: FileSystemNodeWithIds::Folder {
+ content: Default::default(),
+ project_id: "project".to_string(),
+ },
+ project_ids: vec!["project".to_string()],
+ documents: vec![upload_document("document", FileType::Pdf)],
+ })
+ })
+ });
+ repo.expect_delete_uploaded_tree()
+ .withf(|projects, documents| projects == ["project"] && documents == ["document"])
+ .return_once(|_, _| Box::pin(async { Ok(()) }));
+ let service = ProjectServiceImpl::new(
+ repo,
+ RecordingUploadUrls {
+ calls: Arc::new(Mutex::new(Vec::new())),
+ fail_document: true,
+ },
+ RecordingBulkUpload::default(),
+ NullPort,
+ NullPort,
+ NullPort,
+ None,
+ );
+
+ let result = service
+ .upload_folder(
+ user_id("macro|[email protected]"),
+ false,
+ UploadFolderRequest {
+ content: vec![FolderItem {
+ name: "document".to_string(),
+ full_name: "document.pdf".to_string(),
+ file_type: Some(FileType::Pdf),
+ relative_path: "Upload".to_string(),
+ sha: "0123456789abcdef".to_string(),
+ }],
+ root_folder_name: "Upload".to_string(),
+ upload_request_id: "request".to_string(),
+ parent_id: None,
+ },
+ )
+ .await;
+
+ assert!(matches!(result, Err(ProjectError::Internal(_))));
+}
+
+#[tokio::test]
+async fn upload_extract_uses_fixed_request_id() {
+ let fixed_id = Uuid::new_v4();
+ let extract = RecordingExtract {
+ request_ids: Arc::new(Mutex::new(Vec::new())),
+ };
+ let request_ids = extract.request_ids.clone();
+ let service = ProjectServiceImpl::new(
+ MockProjectRepo::new(),
+ RecordingUploadUrls {
+ calls: Arc::new(Mutex::new(Vec::new())),
+ fail_document: false,
+ },
+ extract,
+ NullPort,
+ NullPort,
+ NullPort,
+ Some(fixed_id),
+ );
+
+ let response = service
+ .create_upload_extract_request(
+ user_id("macro|[email protected]"),
+ UploadExtractFolderRequest {
+ sha: "0123456789abcdef".to_string(),
+ name: Some("Upload".to_string()),
+ parent_id: None,
+ },
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(response.request_id, fixed_id.to_string());
+ assert_eq!(*request_ids.lock().unwrap(), vec![fixed_id]);
+}
diff --git a/crates/projects/src/domain/upload.rs b/crates/projects/src/domain/upload.rs
new file mode 100644
index 0000000000..cd3c0e2a1c
--- /dev/null
+++ b/crates/projects/src/domain/upload.rs
@@ -0,0 +1,88 @@
+//! Project folder-upload helpers.
+
+use std::str::FromStr;
+
+use anyhow::Context;
+use model::document::{DocumentMetadata, FileType};
+use model::folder::{FileSystemNode, FolderItem, S3Destination, S3DestinationMap};
+use model::response::PresignedUrl;
+use models_bulk_upload::S3ObjectInfo;
+use s3_key::{build_cloud_storage_bucket_document_key, build_docx_staging_bucket_document_key};
+
+use super::ports::ProjectUploadUrlPort;
+
+/// Build and extract the root node for a folder-upload request.
+pub fn build_root_folder(
+ root_folder_name: &str,
+ content: Vec<FolderItem>,
+) -> anyhow::Result<FileSystemNode> {
+ let file_system = FileSystemNode::build_file_system(root_folder_name, content)?;
+ let FileSystemNode::Folder(mut roots) = file_system else {
+ anyhow::bail!("expected folder upload to produce a folder root");
+ };
+ roots
+ .remove(root_folder_name)
+ .context("root folder not found")
+}
+
+/// Build external presigned URLs or internal bucket destinations for documents.
+pub async fn build_destination_map<U: ProjectUploadUrlPort>(
+ upload_urls: &U,
+ documents: &[DocumentMetadata],
+ internal: bool,
+) -> anyhow::Result<S3DestinationMap> {
+ let mut destinations = S3DestinationMap::new();
+
+ for document in documents {
+ let file_type = document
+ .file_type
+ .as_deref()
+ .map(FileType::from_str)
+ .transpose()?;
+ let sha = document.sha.clone().context("document needs a sha")?;
+
+ if file_type == Some(FileType::Docx) {
+ if !internal {
+ tracing::warn!(
+ document_id = %document.document_id,
+ "external destination not implemented for DOCX upload"
+ );
+ continue;
+ }
+
+ let key = build_docx_staging_bucket_document_key(
+ document.owner.as_ref(),
+ &document.document_id,
+ document.document_version_id,
+ );
+ destinations.insert(
+ document.document_id.clone(),
+ S3Destination::Internal(S3ObjectInfo {
+ bucket: upload_urls.docx_upload_bucket().to_string(),
+ key,
+ }),
+ );
+ continue;
+ }
+
+ let key = build_cloud_storage_bucket_document_key(
+ document.owner.as_ref(),
+ &document.document_id,
+ document.document_version_id,
+ );
+ let destination = if internal {
+ S3Destination::Internal(S3ObjectInfo {
+ bucket: upload_urls.document_storage_bucket().to_string(),
+ key,
+ })
+ } else {
+ let presigned_url = upload_urls
+ .put_document_storage_presigned_url(key, sha.clone(), file_type.into())
+ .await?;
+ S3Destination::External(PresignedUrl { sha, presigned_url })
+ };
+ destinations.insert(document.document_id.clone(), destination);
+ }
+
+ Ok(destinations)
+}
diff --git a/crates/projects/src/inbound.rs b/crates/projects/src/inbound.rs
new file mode 100644
index 0000000000..2b34e4c682
--- /dev/null
+++ b/crates/projects/src/inbound.rs
@@ -0,0 +1,7 @@
+//! Inbound adapters for the projects domain.
+//!
+//! Axum routing is introduced as project routes migrate into this crate.
+
+/// Axum project route adapter.
+#[cfg(feature = "axum")]
+pub mod axum_router;
diff --git a/crates/projects/src/inbound/axum_router.rs b/crates/projects/src/inbound/axum_router.rs
new file mode 100644
index 0000000000..26ea35a49e
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router.rs
@@ -0,0 +1,193 @@
+//! Axum router for project endpoints.
+
+#[cfg(test)]
+mod tests;
+
+pub mod create_project;
+pub mod delete_project;
+pub mod edit_project;
+pub mod get_batch_preview;
+pub mod get_project;
+pub mod get_projects;
+pub mod project_permission;
+pub mod revert_delete_project;
+pub mod upload_folder;
+
+use std::sync::Arc;
+
+use axum::{
+ Json, Router,
+ body::Body,
+ extract::{FromRef, Path, State},
+ http::{Request, StatusCode},
+ middleware::{self, Next},
+ response::IntoResponse,
+};
+use entity_access::domain::ports::EntityAccessService;
+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};
+use model::response::GenericErrorResponse;
+use serde::Deserialize;
+
+use self::{
+ create_project::create_project_handler,
+ delete_project::{delete_project_handler, permanently_delete_project_handler},
+ edit_project::edit_project_handler,
+ get_batch_preview::get_batch_preview_handler,
+ get_project::{get_project_content_handler, get_project_handler},
+ get_projects::{get_pending_projects_handler, get_projects_handler},
+ project_permission::{get_project_access_level_handler, get_project_permissions_handler},
+ revert_delete_project::revert_delete_project_handler,
+ upload_folder::{upload_extract_folder_handler, upload_folder_handler},
+};
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Router state containing project endpoint dependencies.
+pub struct ProjectRouterState<T, Svc, Auth> {
+ /// Project domain service.
+ pub service: Arc<T>,
+ /// Entity access service used by access extractors.
+ pub access_service: Arc<Svc>,
+ /// Request authorization state.
+ pub authorization_state: MacroAuthorizationState<Auth>,
+}
+
+// A derived implementation would unnecessarily require all service types to be `Clone`.
+impl<T, Svc, Auth> Clone for ProjectRouterState<T, Svc, Auth> {
+ fn clone(&self) -> Self {
+ Self {
+ service: self.service.clone(),
+ access_service: self.access_service.clone(),
+ authorization_state: self.authorization_state.clone(),
+ }
+ }
+}
+
+impl<T, Svc, Auth> FromRef<ProjectRouterState<T, Svc, Auth>> for Arc<Svc> {
+ fn from_ref(state: &ProjectRouterState<T, Svc, Auth>) -> Self {
+ state.access_service.clone()
+ }
+}
+
+impl<T, Svc, Auth> FromRef<ProjectRouterState<T, Svc, Auth>> for MacroAuthorizationState<Auth> {
+ fn from_ref(state: &ProjectRouterState<T, Svc, Auth>) -> Self {
+ state.authorization_state.clone()
+ }
+}
+
+/// Project path parameters.
+#[derive(Deserialize)]
+pub struct Params {
+ id: String,
+}
+
+impl IntoResponse for ProjectError {
+ fn into_response(self) -> axum::response::Response {
+ let status = match &self {
+ Self::NotFound(_) => StatusCode::NOT_FOUND,
+ Self::Unauthorized | Self::UnauthorizedWithMessage(_) => StatusCode::UNAUTHORIZED,
+ Self::BadRequest(_)
+ | Self::NameTooLong { .. }
+ | Self::CannotModifyDeleted
+ | Self::RecursiveNesting => StatusCode::BAD_REQUEST,
+ Self::Internal(_) => StatusCode::INTERNAL_SERVER_ERROR,
+ };
+
+ if status.is_server_error() {
+ tracing::error!(error=?self, "project request failed");
+ }
+
+ let message = self.to_string();
+ (
+ status,
+ Json(GenericErrorResponse {
+ error: true,
+ message,
+ }),
+ )
+ .into_response()
+ }
+}
+
+/// Build the project router.
+pub fn projects_router<T, Svc, Auth, S>(state: ProjectRouterState<T, Svc, Auth>) -> Router<S>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+ S: Send + Sync + 'static,
+{
+ let project_routes = Router::new()
+ .route(
+ "/{id}",
+ axum::routing::get(get_project_handler::<T, Svc, Auth>)
+ .patch(edit_project_handler::<T, Svc, Auth>)
+ .delete(delete_project_handler::<T, Svc, Auth>),
+ )
+ .route(
+ "/{id}/content",
+ axum::routing::get(get_project_content_handler::<T, Svc, Auth>),
+ )
+ .route(
+ "/{id}/permissions",
+ axum::routing::get(get_project_permissions_handler::<T, Svc, Auth>),
+ )
+ .route(
+ "/{id}/access_level",
+ axum::routing::get(get_project_access_level_handler::<T, Svc, Auth>),
+ )
+ .route(
+ "/{id}/revert_delete",
+ axum::routing::put(revert_delete_project_handler::<T, Svc, Auth>),
+ )
+ .route(
+ "/{id}/permanent",
+ axum::routing::delete(permanently_delete_project_handler::<T, Svc, Auth>),
+ )
+ .layer(middleware::from_fn_with_state(
+ state.clone(),
+ ensure_project_exists::<T, Svc, Auth>,
+ ));
+
+ Router::new()
+ .merge(project_routes)
+ .route(
+ "/",
+ axum::routing::get(get_projects_handler::<T, Svc, Auth>)
+ .post(create_project_handler::<T, Svc, Auth>),
+ )
+ .route(
+ "/pending",
+ axum::routing::get(get_pending_projects_handler::<T, Svc, Auth>),
+ )
+ .route(
+ "/preview",
+ axum::routing::post(get_batch_preview_handler::<T, Svc, Auth>),
+ )
+ .route(
+ "/upload",
+ axum::routing::post(upload_folder_handler::<T, Svc, Auth>),
+ )
+ .route(
+ "/upload_extract",
+ axum::routing::post(upload_extract_folder_handler::<T, Svc, Auth>),
+ )
+ .with_state(state)
+}
+
+/// Load project context required by project access extractors.
+#[tracing::instrument(skip(state, request, next), err)]
+async fn ensure_project_exists<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ Path(Params { id }): Path<Params>,
+ mut request: Request<Body>,
+ next: Next,
+) -> Result<axum::response::Response, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let project = state.service.internal_get_basic_project(&id).await?;
+ request.extensions_mut().insert(project);
+ Ok(next.run(request).await)
+}
diff --git a/crates/projects/src/inbound/axum_router/create_project.rs b/crates/projects/src/inbound/axum_router/create_project.rs
new file mode 100644
index 0000000000..94c8ecd933
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/create_project.rs
@@ -0,0 +1,43 @@
+//! Handler for creating projects.
+
+use axum::{Json, extract::State};
+use entity_access::{
+ domain::{models::EditAccessLevel, ports::EntityAccessService},
+ inbound::axum_extractors::ProjectBodyAccessLevelExtractorV2,
+};
+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};
+use model::project::{request::CreateProjectRequest, response::CreateProjectResponse};
+
+use super::ProjectRouterState;
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Create a project, optionally beneath an existing project.
+#[utoipa::path(
+ tag = "project",
+ post,
+ path = "/projects",
+ request_body = CreateProjectRequest,
+ responses(
+ (status = 200, body = CreateProjectResponse),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, project), fields(user_id=?user.macro_user_id), err)]
+pub async fn create_project_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ project: ProjectBodyAccessLevelExtractorV2<EditAccessLevel, CreateProjectRequest, Svc, Auth>,
+) -> Result<Json<CreateProjectResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let data = state
+ .service
+ .create_project(user.macro_user_id, project.into_inner())
+ .await?;
+
+ Ok(Json(CreateProjectResponse { error: false, data }))
+}
diff --git a/crates/projects/src/inbound/axum_router/delete_project.rs b/crates/projects/src/inbound/axum_router/delete_project.rs
new file mode 100644
index 0000000000..337ead69d8
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/delete_project.rs
@@ -0,0 +1,108 @@
+//! Handler for soft-deleting projects.
+
+use axum::{Extension, Json, extract::State};
+use entity_access::{
+ domain::{models::OwnerAccessLevel, ports::EntityAccessService},
+ inbound::axum_extractors::ProjectAccessLevelExtractor,
+};
+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};
+use model::project::BasicProject;
+use model::response::{GenericSuccessResponse, SuccessResponse, TypedSuccessResponse};
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+use super::ProjectRouterState;
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Identifiers affected by a recursive project soft deletion.
+#[derive(Debug, Deserialize, Serialize, ToSchema)]
+pub struct ProjectDeleteResponseData {
+ /// Deleted projects, including the requested root.
+ pub project_ids: Vec<String>,
+ /// Deleted documents.
+ pub document_ids: Vec<String>,
+ /// Deleted chats.
+ pub chat_ids: Vec<String>,
+}
+
+/// Successful project deletion response.
+pub type ProjectDeleteResponse = TypedSuccessResponse<ProjectDeleteResponseData>;
+
+/// Soft-delete a project and all of its children.
+#[utoipa::path(
+ tag = "project",
+ delete,
+ path = "/projects/{id}",
+ params(("id" = String, Path, description = "ID of the project")),
+ responses(
+ (status = 200, body = inline(ProjectDeleteResponse)),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, access, project), fields(user_id=?user.macro_user_id), err)]
+pub async fn delete_project_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ access: ProjectAccessLevelExtractor<OwnerAccessLevel, Svc, Auth>,
+ project: Extension<BasicProject>,
+) -> Result<Json<ProjectDeleteResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let deleted = state
+ .service
+ .soft_delete_project(
+ access.entity_access_receipt,
+ project.0,
+ user.macro_user_id.to_string(),
+ )
+ .await?;
+
+ Ok(Json(ProjectDeleteResponse {
+ error: false,
+ data: ProjectDeleteResponseData {
+ project_ids: deleted.project_ids,
+ document_ids: deleted.document_ids,
+ chat_ids: deleted.chat_ids,
+ },
+ }))
+}
+
+/// Permanently delete a soft-deleted project and all of its children.
+#[utoipa::path(
+ tag = "project",
+ delete,
+ operation_id = "permanently_delete_project",
+ path = "/projects/{id}/permanent",
+ params(("id" = String, Path, description = "ID of the project")),
+ responses(
+ (status = 200, body = SuccessResponse),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 404, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, access), fields(user_id=?user.macro_user_id), err)]
+pub async fn permanently_delete_project_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ access: ProjectAccessLevelExtractor<OwnerAccessLevel, Svc, Auth>,
+) -> Result<Json<SuccessResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ state
+ .service
+ .permanently_delete_project(access.entity_access_receipt)
+ .await?;
+
+ Ok(Json(SuccessResponse {
+ error: false,
+ data: GenericSuccessResponse { success: true },
+ }))
+}
diff --git a/crates/projects/src/inbound/axum_router/edit_project.rs b/crates/projects/src/inbound/axum_router/edit_project.rs
new file mode 100644
index 0000000000..585c1d0c51
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/edit_project.rs
@@ -0,0 +1,53 @@
+//! Handler for editing projects.
+
+use axum::{Extension, Json, extract::State};
+use entity_access::{
+ domain::{models::EditAccessLevel, ports::EntityAccessService},
+ inbound::axum_extractors::{ProjectAccessLevelExtractor, ProjectBodyAccessLevelExtractorV2},
+};
+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};
+use model::{
+ project::{BasicProject, request::PatchProjectRequestV2},
+ response::{GenericSuccessResponse, SuccessResponse},
+};
+
+use super::ProjectRouterState;
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Edit project metadata and sharing settings.
+#[utoipa::path(
+ tag = "project",
+ patch,
+ operation_id = "edit_project_v2",
+ path = "/v2/projects/{id}",
+ params(("id" = String, Path, description = "ID of the project")),
+ request_body = PatchProjectRequestV2,
+ responses(
+ (status = 200, body = SuccessResponse),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, access, project, body), fields(user_id=?user.macro_user_id), err)]
+pub async fn edit_project_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ access: ProjectAccessLevelExtractor<EditAccessLevel, Svc, Auth>,
+ project: Extension<BasicProject>,
+ body: ProjectBodyAccessLevelExtractorV2<EditAccessLevel, PatchProjectRequestV2, Svc, Auth>,
+) -> Result<Json<SuccessResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ state
+ .service
+ .edit_project(access.entity_access_receipt, project.0, body.into_inner())
+ .await?;
+
+ Ok(Json(SuccessResponse {
+ error: false,
+ data: GenericSuccessResponse::default(),
+ }))
+}
diff --git a/crates/projects/src/inbound/axum_router/get_batch_preview.rs b/crates/projects/src/inbound/axum_router/get_batch_preview.rs
new file mode 100644
index 0000000000..b154c288b3
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/get_batch_preview.rs
@@ -0,0 +1,41 @@
+//! Handler for batch project previews.
+
+use axum::{Json, extract::State};
+use entity_access::domain::ports::EntityAccessService;
+use macro_authorization::{MacroAuthorizationService, OptionalMacroAuthorizationExtractor};
+use model::project::{
+ request::GetBatchProjectPreviewRequest, response::GetBatchProjectPreviewResponse,
+};
+
+use super::ProjectRouterState;
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Get previews for a batch of project IDs.
+#[utoipa::path(
+ tag = "project",
+ post,
+ path = "/projects/preview",
+ operation_id = "get_batch_project_preview",
+ responses(
+ (status = 200, body = GetBatchProjectPreviewResponse),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, request), fields(user_id=?user.macro_user_id), err)]
+pub async fn get_batch_preview_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: OptionalMacroAuthorizationExtractor<Auth>,
+ Json(request): Json<GetBatchProjectPreviewRequest>,
+) -> Result<Json<GetBatchProjectPreviewResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let previews = state
+ .service
+ .get_batch_preview(user.macro_user_id, request.project_ids)
+ .await?;
+ Ok(Json(GetBatchProjectPreviewResponse { previews }))
+}
diff --git a/crates/projects/src/inbound/axum_router/get_project.rs b/crates/projects/src/inbound/axum_router/get_project.rs
new file mode 100644
index 0000000000..837daeed54
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/get_project.rs
@@ -0,0 +1,71 @@
+//! Handlers for reading a project and its content.
+
+use axum::{Json, extract::State};
+use entity_access::{
+ domain::{models::ViewAccessLevel, ports::EntityAccessService},
+ inbound::axum_extractors::ProjectAccessLevelExtractor,
+};
+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};
+use model::project::response::{GetProjectContentResponse, GetProjectResponse};
+
+use super::ProjectRouterState;
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Get project metadata.
+#[utoipa::path(
+ get,
+ path = "/projects/{id}",
+ params(("id" = String, Path, description = "ID of the project")),
+ responses(
+ (status = 200, body = GetProjectResponse),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, access), fields(user_id=?user.macro_user_id), err)]
+pub async fn get_project_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ access: ProjectAccessLevelExtractor<ViewAccessLevel, Svc, Auth>,
+) -> Result<Json<GetProjectResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let data = state
+ .service
+ .get_project(access.entity_access_receipt)
+ .await?;
+ Ok(Json(GetProjectResponse { error: false, data }))
+}
+
+/// Get a project's immediate children.
+#[utoipa::path(
+ tag = "project",
+ get,
+ path = "/projects/{id}/content",
+ params(("id" = String, Path, description = "ID of the project")),
+ responses(
+ (status = 200, body = GetProjectContentResponse),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, access), fields(user_id=?user.macro_user_id), err)]
+pub async fn get_project_content_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ access: ProjectAccessLevelExtractor<ViewAccessLevel, Svc, Auth>,
+) -> Result<Json<GetProjectContentResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let data = state
+ .service
+ .get_project_content(access.entity_access_receipt)
+ .await?;
+ Ok(Json(GetProjectContentResponse { error: false, data }))
+}
diff --git a/crates/projects/src/inbound/axum_router/get_projects.rs b/crates/projects/src/inbound/axum_router/get_projects.rs
new file mode 100644
index 0000000000..3f4a9f4772
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/get_projects.rs
@@ -0,0 +1,71 @@
+//! Handlers for listing projects.
+
+use axum::{Json, extract::State};
+use entity_access::domain::ports::EntityAccessService;
+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};
+use model::{project::response::GetProjectsResponse, response::TypedSuccessResponse};
+
+use super::ProjectRouterState;
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Successful pending-project list response.
+pub type PendingProjectsResponse = TypedSuccessResponse<Vec<model::project::PendingProject>>;
+
+/// List projects visible to the authenticated user.
+#[utoipa::path(
+ tag = "project",
+ get,
+ path = "/projects",
+ responses(
+ (status = 200, body = GetProjectsResponse),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user), fields(user_id=?user.macro_user_id), err)]
+pub async fn get_projects_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+) -> Result<Json<GetProjectsResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let projects = state.service.list_projects(user.macro_user_id).await?;
+ Ok(Json(GetProjectsResponse {
+ error: false,
+ data: projects,
+ }))
+}
+
+/// List pending root projects owned by the authenticated user.
+#[utoipa::path(
+ tag = "project",
+ get,
+ path = "/projects/pending",
+ responses(
+ (status = 200, body = inline(PendingProjectsResponse)),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user), fields(user_id=?user.macro_user_id), err)]
+pub async fn get_pending_projects_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+) -> Result<Json<PendingProjectsResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let projects = state
+ .service
+ .list_pending_projects(user.macro_user_id)
+ .await?;
+ Ok(Json(PendingProjectsResponse {
+ error: false,
+ data: projects,
+ }))
+}
diff --git a/crates/projects/src/inbound/axum_router/project_permission.rs b/crates/projects/src/inbound/axum_router/project_permission.rs
new file mode 100644
index 0000000000..806d8b3929
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/project_permission.rs
@@ -0,0 +1,78 @@
+//! Handlers for project permissions and caller access levels.
+
+use axum::{Json, extract::State};
+use entity_access::{
+ domain::{
+ models::{OwnerAccessLevel, ViewAccessLevel},
+ ports::EntityAccessService,
+ },
+ inbound::axum_extractors::ProjectAccessLevelExtractor,
+};
+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};
+use models_permissions::share_permission::{SharePermissionV2, access_level::AccessLevel};
+
+use super::ProjectRouterState;
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Get a project's share permissions.
+#[utoipa::path(
+ tag = "project",
+ get,
+ path = "/projects/{id}/permissions",
+ operation_id = "get_project_permissions_v2",
+ params(("id" = String, Path, description = "ID of the project")),
+ responses(
+ (status = 200, body = SharePermissionV2),
+ (status = 404, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, access), fields(user_id=?user.macro_user_id), err)]
+pub async fn get_project_permissions_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ access: ProjectAccessLevelExtractor<OwnerAccessLevel, Svc, Auth>,
+) -> Result<Json<SharePermissionV2>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let permissions = state
+ .service
+ .get_project_permissions(access.entity_access_receipt)
+ .await?;
+ Ok(Json(permissions))
+}
+
+/// Get the caller's project access level.
+#[utoipa::path(
+ tag = "project",
+ get,
+ path = "/projects/{id}/access_level",
+ operation_id = "get_project_user_access_level",
+ params(("id" = String, Path, description = "ID of the project")),
+ responses(
+ (status = 200, body = AccessLevel),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 404, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, access), fields(user_id=?user.macro_user_id), err)]
+pub async fn get_project_access_level_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ access: ProjectAccessLevelExtractor<ViewAccessLevel, Svc, Auth>,
+) -> Result<Json<AccessLevel>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let access_level = state
+ .service
+ .get_project_access_level(access.entity_access_receipt)
+ .await?;
+ Ok(Json(access_level))
+}
diff --git a/crates/projects/src/inbound/axum_router/revert_delete_project.rs b/crates/projects/src/inbound/axum_router/revert_delete_project.rs
new file mode 100644
index 0000000000..a7fd221777
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/revert_delete_project.rs
@@ -0,0 +1,51 @@
+//! Handler for restoring soft-deleted projects.
+
+use axum::{Extension, Json, extract::State};
+use entity_access::{
+ domain::{models::OwnerAccessLevel, ports::EntityAccessService},
+ inbound::axum_extractors::ProjectAccessLevelExtractor,
+};
+use macro_authorization::MacroAuthorizationService;
+use model::{
+ project::BasicProject,
+ response::{GenericSuccessResponse, SuccessResponse},
+};
+
+use super::ProjectRouterState;
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Restore a soft-deleted project and its children.
+#[utoipa::path(
+ tag = "project",
+ put,
+ operation_id = "revert_delete_project",
+ path = "/projects/{id}/revert_delete",
+ params(("id" = String, Path, description = "ID of the project")),
+ responses(
+ (status = 200, body = SuccessResponse),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 404, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, access, project), err)]
+pub async fn revert_delete_project_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ access: ProjectAccessLevelExtractor<OwnerAccessLevel, Svc, Auth>,
+ project: Extension<BasicProject>,
+) -> Result<Json<SuccessResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ state
+ .service
+ .revert_delete_project(access.entity_access_receipt, project.0)
+ .await?;
+
+ Ok(Json(SuccessResponse {
+ error: false,
+ data: GenericSuccessResponse::default(),
+ }))
+}
diff --git a/crates/projects/src/inbound/axum_router/tests.rs b/crates/projects/src/inbound/axum_router/tests.rs
new file mode 100644
index 0000000000..6122acd4eb
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/tests.rs
@@ -0,0 +1,867 @@
+use std::{
+ collections::HashMap,
+ sync::{Arc, Mutex},
+};
+
+use axum::{
+ Router,
+ body::Body,
+ http::{Request, StatusCode},
+};
+use entity_access::domain::{
+ models::{
+ AccessError, AccessLevel, BotId, CallChannelInfo, EntityAccessReceipt, EntityPermission,
+ EntityType, RequiredPermission, UserTeamInfo,
+ },
+ ports::EntityAccessService,
+};
+use http_body_util::BodyExt;
+use macro_authorization::{
+ InternalIdentityClaims, MacroAuthorizationError, MacroAuthorizationService,
+ MacroAuthorizationState,
+};
+use macro_user_id::{lowercased::Lowercase, user_id::MacroUserId, user_id::MacroUserIdStr};
+use model::{
+ folder::{FileSystemNodeWithIds, UploadFolderRequest, UploadFolderResponseData},
+ item::ItemWithUserAccessLevel,
+ project::{
+ BasicProject, PendingProject, Project, ProjectPreview,
+ request::{CreateProjectRequest, PatchProjectRequestV2},
+ response::GetProjectResponseData,
+ },
+};
+use model_user::UserContext;
+use models_bulk_upload::{UploadExtractFolderRequest, UploadExtractFolderResponseData};
+use models_permissions::share_permission::{
+ SharePermissionV2, access_level::AccessLevel as ShareAccessLevel,
+};
+use rootcause::Report;
+use serde_json::{Value, json};
+use tower::ServiceExt;
+use uuid::Uuid;
+
+use super::{ProjectRouterState, projects_router};
+use crate::domain::{
+ models::{ProjectError, SoftDeleteResult},
+ ports::ProjectService,
+};
+
+const TOKEN: &str = "valid-token";
+const INTERNAL_KEY: &str = "internal-key";
+const USER_ID: &str = "macro|[email protected]";
+const PROJECT_ID: &str = "project-1";
+
+#[derive(Clone)]
+struct FakeProjectService {
+ basic_project: Arc<Mutex<Result<BasicProject, String>>>,
+ mutations: Arc<Mutex<Vec<&'static str>>>,
+ upload_internal_flags: Arc<Mutex<Vec<bool>>>,
+}
+
+impl FakeProjectService {
+ fn with_project(owner: &str, deleted: bool) -> Self {
+ Self {
+ basic_project: Arc::new(Mutex::new(Ok(BasicProject {
+ id: PROJECT_ID.to_string(),
+ user_id: user_id(owner),
+ parent_id: None,
+ name: "Project".to_string(),
+ deleted_at: deleted.then(chrono::Utc::now),
+ }))),
+ mutations: Arc::new(Mutex::new(Vec::new())),
+ upload_internal_flags: Arc::new(Mutex::new(Vec::new())),
+ }
+ }
+
+ fn missing() -> Self {
+ Self {
+ basic_project: Arc::new(Mutex::new(Err("missing".to_string()))),
+ mutations: Arc::new(Mutex::new(Vec::new())),
+ upload_internal_flags: Arc::new(Mutex::new(Vec::new())),
+ }
+ }
+}
+
+impl ProjectService for FakeProjectService {
+ async fn list_projects(
+ &self,
+ _user_id: MacroUserIdStr<'static>,
+ ) -> Result<Vec<Project>, ProjectError> {
+ Ok(vec![project()])
+ }
+
+ async fn list_pending_projects(
+ &self,
+ _user_id: MacroUserIdStr<'static>,
+ ) -> Result<Vec<PendingProject>, ProjectError> {
+ Ok(Vec::new())
+ }
+
+ async fn get_project(
+ &self,
+ _receipt: EntityAccessReceipt<entity_access::domain::models::ViewAccessLevel>,
+ ) -> Result<GetProjectResponseData, ProjectError> {
+ Ok(GetProjectResponseData {
+ project_metadata: project(),
+ user_access_level: ShareAccessLevel::Owner,
+ })
+ }
+
+ async fn get_project_content(
+ &self,
+ _receipt: EntityAccessReceipt<entity_access::domain::models::ViewAccessLevel>,
+ ) -> Result<Vec<ItemWithUserAccessLevel>, ProjectError> {
+ Ok(Vec::new())
+ }
+
+ async fn get_project_permissions(
+ &self,
+ _receipt: EntityAccessReceipt<entity_access::domain::models::OwnerAccessLevel>,
+ ) -> Result<SharePermissionV2, ProjectError> {
+ panic!("permissions are not used by these tests")
+ }
+
+ async fn get_project_access_level(
+ &self,
+ _receipt: EntityAccessReceipt<entity_access::domain::models::ViewAccessLevel>,
+ ) -> Result<ShareAccessLevel, ProjectError> {
+ Ok(ShareAccessLevel::Owner)
+ }
+
+ async fn create_project(
+ &self,
+ _actor: MacroUserIdStr<'static>,
+ _args: CreateProjectRequest,
+ ) -> Result<Project, ProjectError> {
+ self.mutations
+ .lock()
+ .expect("mutation lock poisoned")
+ .push("create");
+ Ok(project())
+ }
+
+ async fn edit_project(
+ &self,
+ _receipt: EntityAccessReceipt<entity_access::domain::models::EditAccessLevel>,
+ _project: BasicProject,
+ _args: PatchProjectRequestV2,
+ ) -> Result<(), ProjectError> {
+ if _project.deleted_at.is_some() {
+ return Err(ProjectError::CannotModifyDeleted);
+ }
+ self.mutations
+ .lock()
+ .expect("mutation lock poisoned")
+ .push("edit");
+ Ok(())
+ }
+
+ async fn soft_delete_project(
+ &self,
+ _receipt: EntityAccessReceipt<entity_access::domain::models::OwnerAccessLevel>,
+ _project: BasicProject,
+ _actor_user_id: String,
+ ) -> Result<SoftDeleteResult, ProjectError> {
+ self.mutations
+ .lock()
+ .expect("mutation lock poisoned")
+ .push("delete");
+ Ok(SoftDeleteResult {
+ project_ids: vec![PROJECT_ID.to_string()],
+ document_ids: vec!["document-1".to_string()],
+ chat_ids: vec!["chat-1".to_string()],
+ })
+ }
+
+ async fn permanently_delete_project(
+ &self,
+ _receipt: EntityAccessReceipt<entity_access::domain::models::OwnerAccessLevel>,
+ ) -> Result<(), ProjectError> {
+ self.mutations
+ .lock()
+ .expect("mutation lock poisoned")
+ .push("permanent_delete");
+ Ok(())
+ }
+
+ async fn revert_delete_project(
+ &self,
+ _receipt: EntityAccessReceipt<entity_access::domain::models::OwnerAccessLevel>,
+ _project: BasicProject,
+ ) -> Result<(), ProjectError> {
+ self.mutations
+ .lock()
+ .expect("mutation lock poisoned")
+ .push("revert");
+ Ok(())
+ }
+
+ async fn upload_folder(
+ &self,
+ _actor: MacroUserIdStr<'static>,
+ internal: bool,
+ _args: UploadFolderRequest,
+ ) -> Result<UploadFolderResponseData, ProjectError> {
+ self.upload_internal_flags
+ .lock()
+ .expect("upload flag lock poisoned")
+ .push(internal);
+ Ok(UploadFolderResponseData {
+ file_system: FileSystemNodeWithIds::Folder {
+ content: HashMap::new(),
+ project_id: PROJECT_ID.to_string(),
+ },
+ destination_map: HashMap::new(),
+ })
+ }
+
+ async fn create_upload_extract_request(
+ &self,
+ _actor: MacroUserIdStr<'static>,
+ _args: UploadExtractFolderRequest,
+ ) -> Result<UploadExtractFolderResponseData, ProjectError> {
+ panic!("upload extraction is not used by these tests")
+ }
+
+ async fn mark_projects_uploaded(
+ &self,
+ _root_project_id: &str,
+ ) -> Result<Vec<String>, ProjectError> {
+ Ok(vec![PROJECT_ID.to_string(), "project-child".to_string()])
+ }
+
+ async fn get_batch_preview(
+ &self,
+ _actor: Option<MacroUserIdStr<'static>>,
+ _project_ids: Vec<String>,
+ ) -> Result<Vec<ProjectPreview>, ProjectError> {
+ Ok(Vec::new())
+ }
+
+ async fn internal_get_basic_project(
+ &self,
+ _project_id: &str,
+ ) -> Result<BasicProject, ProjectError> {
+ self.basic_project
+ .lock()
+ .expect("basic project lock poisoned")
+ .clone()
+ .map_err(ProjectError::NotFound)
+ }
+}
+
+#[derive(Clone)]
+struct FakeEntityAccessService {
+ access_level: Option<AccessLevel>,
+}
+
+impl EntityAccessService for FakeEntityAccessService {
+ async fn generate_entity_access_receipt<T: RequiredPermission>(
+ &self,
+ _user_id: &MacroUserId<Lowercase<'_>>,
+ _user_org_id: Option<i64>,
+ _entity_id: &str,
+ _entity_type: EntityType,
+ ) -> Result<EntityAccessReceipt<T>, AccessError> {
+ Err(AccessError::Unauthorized)
+ }
+
+ async fn generate_bot_entity_access_receipt<T: RequiredPermission>(
+ &self,
+ _bot_id: BotId,
+ _entity_id: &str,
+ _entity_type: EntityType,
+ ) -> Result<EntityAccessReceipt<T>, AccessError> {
+ panic!("unexpected bot receipt generation")
+ }
+
+ async fn get_access_level(
+ &self,
+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,
+ _entity_id: &str,
+ _entity_type: EntityType,
+ ) -> Result<Option<AccessLevel>, AccessError> {
+ Ok(self.access_level)
+ }
+
+ async fn check_access(
+ &self,
+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,
+ _entity_id: &str,
+ _entity_type: EntityType,
+ _required_level: AccessLevel,
+ ) -> Result<AccessLevel, AccessError> {
+ panic!("unexpected access check")
+ }
+
+ async fn check_public_access(
+ &self,
+ _entity_id: &str,
+ _entity_type: EntityType,
+ _required_level: AccessLevel,
+ ) -> Result<AccessLevel, AccessError> {
+ panic!("unexpected public access check")
+ }
+
+ async fn get_entity_permission(
+ &self,
+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,
+ _entity_id: &str,
+ _entity_type: EntityType,
+ _user_org_id: Option<i64>,
+ ) -> Result<EntityPermission, AccessError> {
+ panic!("unexpected permission lookup")
+ }
+
+ async fn get_crm_entity_permission_with_team(
+ &self,
+ _user_id: Option<&MacroUserId<Lowercase<'_>>>,
+ _entity_id: &str,
+ _entity_type: EntityType,
+ ) -> Result<(EntityPermission, Uuid), AccessError> {
+ panic!("unexpected CRM permission lookup")
+ }
+
+ async fn get_users_by_entity(
+ &self,
+ _entity_id: &str,
+ _entity_type: EntityType,
+ ) -> Result<Vec<MacroUserIdStr<'static>>, AccessError> {
+ panic!("unexpected user lookup")
+ }
+
+ async fn get_call_channel(
+ &self,
+ _call_id: &Uuid,
+ ) -> Result<Option<CallChannelInfo>, AccessError> {
+ panic!("unexpected call lookup")
+ }
+
+ async fn get_call_channel_by_channel_id(
+ &self,
+ _channel_id: &Uuid,
+ ) -> Result<Option<CallChannelInfo>, AccessError> {
+ panic!("unexpected channel lookup")
+ }
+
+ async fn get_user_team(
+ &self,
+ _user_id: &MacroUserId<Lowercase<'_>>,
+ ) -> Result<Option<UserTeamInfo>, AccessError> {
+ panic!("unexpected team lookup")
+ }
+}
+
+#[derive(Clone, Default)]
+struct FakeAuthorizationService;
+
+impl MacroAuthorizationService for FakeAuthorizationService {
+ async fn authorize(&self, token: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {
+ if token != TOKEN {
+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));
+ }
+ Ok(user_context(USER_ID))
+ }
+
+ async fn authorize_internal(
+ &self,
+ provided_key: &str,
+ claims: InternalIdentityClaims,
+ ) -> Result<Option<UserContext>, Report<MacroAuthorizationError>> {
+ if provided_key != INTERNAL_KEY {
+ return Err(Report::new(MacroAuthorizationError::InvalidCredentials));
+ }
+ Ok(claims.user_id.map(|user_id| user_context(&user_id)))
+ }
+}
+
+fn router(service: FakeProjectService, access_level: Option<AccessLevel>) -> Router {
+ projects_router::<FakeProjectService, FakeEntityAccessService, FakeAuthorizationService, ()>(
+ ProjectRouterState {
+ service: Arc::new(service),
+ access_service: Arc::new(FakeEntityAccessService { access_level }),
+ authorization_state: MacroAuthorizationState::new(Arc::new(FakeAuthorizationService)),
+ },
+ )
+}
+
+fn user_id(value: &str) -> MacroUserIdStr<'static> {
+ MacroUserIdStr::try_from(value.to_string()).expect("test user id should be valid")
+}
+
+fn user_context(value: &str) -> UserContext {
+ UserContext {
+ user_id: value.to_string(),
+ fusion_user_id: "fusion-user".to_string(),
+ permissions: None,
+ organization_id: None,
+ }
+}
+
+fn project() -> Project {
+ Project {
+ id: PROJECT_ID.to_string(),
+ name: "Project".to_string(),
+ user_id: USER_ID.to_string(),
+ parent_id: None,
+ created_at: None,
+ updated_at: None,
+ deleted_at: None,
+ }
+}
+
+fn authenticated_request(uri: &str) -> Request<Body> {
+ Request::get(uri)
+ .header("authorization", format!("Bearer {TOKEN}"))
+ .body(Body::empty())
+ .expect("request should be valid")
+}
+
+fn authenticated_json_request(method: &str, uri: &str, body: Value) -> Request<Body> {
+ Request::builder()
+ .method(method)
+ .uri(uri)
+ .header("authorization", format!("Bearer {TOKEN}"))
+ .header("content-type", "application/json")
+ .body(Body::from(body.to_string()))
+ .expect("request should be valid")
+}
+
+fn internal_json_request(method: &str, uri: &str, body: Value) -> Request<Body> {
+ Request::builder()
+ .method(method)
+ .uri(uri)
+ .header("x-internal-auth-key", INTERNAL_KEY)
+ .header("content-type", "application/json")
+ .body(Body::from(body.to_string()))
+ .expect("request should be valid")
+}
+
+fn internal_identity_json_request(method: &str, uri: &str, body: Value) -> Request<Body> {
+ Request::builder()
+ .method(method)
+ .uri(uri)
+ .header("x-internal-auth-key", INTERNAL_KEY)
+ .header("x-internal-macro-user-id", USER_ID)
+ .header("x-internal-fusionauth-user-id", "fusion-user")
+ .header("content-type", "application/json")
+ .body(Body::from(body.to_string()))
+ .expect("request should be valid")
+}
+
+async fn json_body(response: axum::response::Response) -> Value {
+ let bytes = response
+ .into_body()
+ .collect()
+ .await
+ .expect("response body should be readable")
+ .to_bytes();
+ serde_json::from_slice(&bytes).expect("response should be JSON")
+}
+
+#[tokio::test]
+async fn list_projects_returns_exact_success_envelope() {
+ let response = router(FakeProjectService::with_project(USER_ID, false), None)
+ .oneshot(authenticated_request("/"))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(
+ json_body(response).await,
+ json!({
+ "error": false,
+ "data": [{
+ "id": PROJECT_ID,
+ "name": "Project",
+ "userId": USER_ID,
+ "createdAt": null,
+ "updatedAt": null,
+ "deletedAt": null
+ }]
+ })
+ );
+}
+
+#[tokio::test]
+async fn required_route_rejects_missing_credentials() {
+ let request = Request::get("/")
+ .body(Body::empty())
+ .expect("valid request");
+ let response = router(FakeProjectService::with_project(USER_ID, false), None)
+ .oneshot(request)
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+}
+
+#[tokio::test]
+async fn preview_allows_anonymous_requests_with_exact_envelope() {
+ let request = Request::post("/preview")
+ .header("content-type", "application/json")
+ .body(Body::from(r#"{"projectIds":["project-1"]}"#))
+ .expect("valid request");
+ let response = router(FakeProjectService::with_project(USER_ID, false), None)
+ .oneshot(request)
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(json_body(response).await, json!({ "previews": [] }));
+}
+
+#[tokio::test]
+async fn middleware_returns_generic_404_envelope() {
+ let response = router(FakeProjectService::missing(), None)
+ .oneshot(authenticated_request(&format!("/{PROJECT_ID}")))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::NOT_FOUND);
+ assert_eq!(
+ json_body(response).await,
+ json!({ "error": true, "message": "project not found: missing" })
+ );
+}
+
+#[tokio::test]
+async fn access_extractor_denial_prevents_handler() {
+ let response = router(
+ FakeProjectService::with_project("macro|[email protected]", false),
+ None,
+ )
+ .oneshot(authenticated_request(&format!("/{PROJECT_ID}")))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+}
+
+#[tokio::test]
+async fn create_returns_project_success_envelope() {
+ let response = router(FakeProjectService::with_project(USER_ID, false), None)
+ .oneshot(authenticated_json_request(
+ "POST",
+ "/",
+ json!({ "name": "Created", "projectParentId": null }),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(
+ json_body(response).await,
+ json!({
+ "error": false,
+ "data": {
+ "id": PROJECT_ID,
+ "name": "Project",
+ "userId": USER_ID,
+ "createdAt": null,
+ "updatedAt": null,
+ "deletedAt": null
+ }
+ })
+ );
+}
+
+#[tokio::test]
+async fn edit_permission_denial_prevents_mutation() {
+ let response = router(
+ FakeProjectService::with_project("macro|[email protected]", false),
+ Some(AccessLevel::View),
+ )
+ .oneshot(authenticated_json_request(
+ "PATCH",
+ &format!("/{PROJECT_ID}"),
+ json!({ "name": "Edited" }),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+}
+
+#[tokio::test]
+async fn owner_can_edit_with_exact_success_response() {
+ let response = router(FakeProjectService::with_project(USER_ID, false), None)
+ .oneshot(authenticated_json_request(
+ "PATCH",
+ &format!("/{PROJECT_ID}"),
+ json!({ "name": "Edited" }),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(
+ json_body(response).await,
+ json!({ "error": false, "data": { "success": true } })
+ );
+}
+
+#[tokio::test]
+async fn edit_rejects_deleted_project() {
+ let response = router(FakeProjectService::with_project(USER_ID, true), None)
+ .oneshot(authenticated_json_request(
+ "PATCH",
+ &format!("/{PROJECT_ID}"),
+ json!({ "name": "Edited" }),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+ assert_eq!(
+ json_body(response).await,
+ json!({ "error": true, "message": "cannot modify deleted project" })
+ );
+}
+
+#[tokio::test]
+async fn edit_body_parent_denial_prevents_handler() {
+ let response = router(FakeProjectService::with_project(USER_ID, false), None)
+ .oneshot(authenticated_json_request(
+ "PATCH",
+ &format!("/{PROJECT_ID}"),
+ json!({ "projectParentId": Uuid::new_v4().to_string() }),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+}
+
+#[tokio::test]
+async fn owner_can_delete_with_exact_response_body() {
+ let response = router(FakeProjectService::with_project(USER_ID, false), None)
+ .oneshot(authenticated_json_request(
+ "DELETE",
+ &format!("/{PROJECT_ID}"),
+ json!({}),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(
+ json_body(response).await,
+ json!({
+ "error": false,
+ "data": {
+ "project_ids": [PROJECT_ID],
+ "document_ids": ["document-1"],
+ "chat_ids": ["chat-1"]
+ }
+ })
+ );
+}
+
+#[tokio::test]
+async fn deleted_project_creator_can_revert() {
+ let response = router(FakeProjectService::with_project(USER_ID, true), None)
+ .oneshot(authenticated_json_request(
+ "PUT",
+ &format!("/{PROJECT_ID}/revert_delete"),
+ json!({}),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(
+ json_body(response).await,
+ json!({ "error": false, "data": { "success": true } })
+ );
+}
+
+#[tokio::test]
+async fn internal_actor_can_revert_deleted_project() {
+ let response = router(
+ FakeProjectService::with_project("macro|[email protected]", true),
+ None,
+ )
+ .oneshot(internal_json_request(
+ "PUT",
+ &format!("/{PROJECT_ID}/revert_delete"),
+ json!({}),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(
+ json_body(response).await,
+ json!({ "error": false, "data": { "success": true } })
+ );
+}
+
+#[tokio::test]
+async fn soft_deleted_project_rejects_non_owner_even_with_shared_access() {
+ let response = router(
+ FakeProjectService::with_project("macro|[email protected]", true),
+ Some(AccessLevel::View),
+ )
+ .oneshot(authenticated_request(&format!(
+ "/{PROJECT_ID}/access_level"
+ )))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+ assert_eq!(
+ json_body(response).await,
+ json!({ "message": "only owner can access deleted resource" })
+ );
+}
+
+#[tokio::test]
+async fn upload_with_parent_denial_prevents_service_call() {
+ let service = FakeProjectService::with_project(USER_ID, false);
+ let calls = service.upload_internal_flags.clone();
+ let response = router(service, None)
+ .oneshot(authenticated_json_request(
+ "POST",
+ "/upload",
+ json!({
+ "content": [],
+ "rootFolderName": "Folder",
+ "uploadRequestId": "request-1",
+ "parentId": Uuid::new_v4().to_string()
+ }),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+ assert!(calls.lock().expect("upload flag lock poisoned").is_empty());
+}
+
+#[tokio::test]
+async fn upload_extract_with_parent_denial_prevents_service_call() {
+ let response = router(FakeProjectService::with_project(USER_ID, false), None)
+ .oneshot(authenticated_json_request(
+ "POST",
+ "/upload_extract",
+ json!({
+ "sha": "archive-sha",
+ "parentId": Uuid::new_v4().to_string()
+ }),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+}
+
+#[tokio::test]
+async fn anonymous_upload_is_rejected() {
+ let request = Request::post("/upload")
+ .header("content-type", "application/json")
+ .body(Body::from(
+ json!({
+ "content": [],
+ "rootFolderName": "Folder",
+ "uploadRequestId": "request-1"
+ })
+ .to_string(),
+ ))
+ .expect("request should be valid");
+ let response = router(FakeProjectService::with_project(USER_ID, false), None)
+ .oneshot(request)
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+}
+
+#[tokio::test]
+async fn internal_upload_selects_internal_destinations_with_exact_lambda_json() {
+ let service = FakeProjectService::with_project(USER_ID, false);
+ let flags = service.upload_internal_flags.clone();
+ let response = router(service, None)
+ .oneshot(internal_identity_json_request(
+ "POST",
+ "/upload",
+ json!({
+ "content": [],
+ "rootFolderName": "Folder",
+ "uploadRequestId": "lambda-request"
+ }),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(&*flags.lock().expect("upload flag lock poisoned"), &[true]);
+ assert_eq!(
+ json_body(response).await,
+ json!({
+ "error": false,
+ "data": {
+ "fileSystem": {
+ "type": "folder",
+ "content": {},
+ "project_id": PROJECT_ID
+ },
+ "destinationMap": {}
+ }
+ })
+ );
+}
+
+#[tokio::test]
+async fn permanent_delete_requires_owner_access() {
+ let service = FakeProjectService::with_project("macro|[email protected]", true);
+ let mutations = service.mutations.clone();
+ let response = router(service, Some(AccessLevel::Edit))
+ .oneshot(
+ Request::delete(format!("/{PROJECT_ID}/permanent"))
+ .header("authorization", format!("Bearer {TOKEN}"))
+ .body(Body::empty())
+ .expect("request should be valid"),
+ )
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+ assert!(mutations.lock().expect("mutation lock poisoned").is_empty());
+}
+
+#[tokio::test]
+async fn mark_uploaded_preserves_exact_lambda_request_and_response_json() {
+ use super::upload_folder::mark_uploaded_handler;
+
+ let state = ProjectRouterState {
+ service: Arc::new(FakeProjectService::with_project(USER_ID, false)),
+ access_service: Arc::new(FakeEntityAccessService { access_level: None }),
+ authorization_state: MacroAuthorizationState::new(Arc::new(FakeAuthorizationService)),
+ };
+ let router = Router::new()
+ .route(
+ "/mark_uploaded",
+ axum::routing::post(
+ mark_uploaded_handler::<
+ FakeProjectService,
+ FakeEntityAccessService,
+ FakeAuthorizationService,
+ >,
+ ),
+ )
+ .with_state(state);
+ let response = router
+ .oneshot(internal_identity_json_request(
+ "POST",
+ "/mark_uploaded",
+ json!({ "projectId": PROJECT_ID }),
+ ))
+ .await
+ .expect("router should respond");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(
+ json_body(response).await,
+ json!({ "projectIds": [PROJECT_ID, "project-child"] })
+ );
+}
diff --git a/crates/projects/src/inbound/axum_router/upload_folder.rs b/crates/projects/src/inbound/axum_router/upload_folder.rs
new file mode 100644
index 0000000000..f6976a4d8b
--- /dev/null
+++ b/crates/projects/src/inbound/axum_router/upload_folder.rs
@@ -0,0 +1,132 @@
+//! Handlers for project folder uploads.
+
+use axum::{Json, extract::State};
+use entity_access::domain::{
+ models::{EditAccessLevel, EntityType},
+ ports::EntityAccessService,
+};
+use macro_authorization::{MacroAuthorizationExtractor, MacroAuthorizationService};
+use model::{
+ folder::{UploadFolderRequest, UploadFolderResponseData},
+ response::TypedSuccessResponse,
+};
+use models_bulk_upload::{
+ MarkProjectUploadedRequest, MarkProjectUploadedResponse, UploadExtractFolderRequest,
+ UploadExtractFolderResponseData,
+};
+
+use super::ProjectRouterState;
+use crate::domain::{models::ProjectError, ports::ProjectService};
+
+/// Successful folder-upload response.
+pub type UploadFolderResponse = TypedSuccessResponse<UploadFolderResponseData>;
+
+/// Successful upload-extract response.
+pub type UploadExtractFolderResponse = TypedSuccessResponse<UploadExtractFolderResponseData>;
+
+/// Upload a folder tree and create its upload destinations.
+#[utoipa::path(
+ post,
+ path = "/projects/upload",
+ responses(
+ (status = 200, body = inline(UploadFolderResponse)),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 404, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, request), fields(user_id=%user.macro_user_id), err)]
+pub async fn upload_folder_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ Json(request): Json<UploadFolderRequest>,
+) -> Result<Json<UploadFolderResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ ensure_parent_edit_access(&state, &user, request.parent_id.as_deref()).await?;
+ let data = state
+ .service
+ .upload_folder(user.macro_user_id, user.is_internal_access, request)
+ .await?;
+
+ Ok(Json(UploadFolderResponse { error: false, data }))
+}
+
+/// Create a request for extracting an uploaded folder archive.
+#[utoipa::path(
+ tag = "project",
+ post,
+ path = "/projects/upload_extract",
+ responses(
+ (status = 200, body = inline(UploadExtractFolderResponse)),
+ (status = 401, body = model::response::GenericErrorResponse),
+ (status = 404, body = model::response::GenericErrorResponse),
+ (status = 500, body = model::response::GenericErrorResponse),
+ )
+)]
+#[tracing::instrument(skip(state, user, request), fields(user_id=%user.macro_user_id), err)]
+pub async fn upload_extract_folder_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ Json(request): Json<UploadExtractFolderRequest>,
+) -> Result<Json<UploadExtractFolderResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ ensure_parent_edit_access(&state, &user, request.parent_id.as_deref()).await?;
+ let data = state
+ .service
+ .create_upload_extract_request(user.macro_user_id, request)
+ .await?;
+
+ Ok(Json(UploadExtractFolderResponse { error: false, data }))
+}
+
+async fn ensure_parent_edit_access<T, Svc, Auth>(
+ state: &ProjectRouterState<T, Svc, Auth>,
+ user: &MacroAuthorizationExtractor<Auth>,
+ parent_id: Option<&str>,
+) -> Result<(), ProjectError>
+where
+ Svc: EntityAccessService,
+{
+ let Some(parent_id) = parent_id.filter(|_| !user.is_internal_access) else {
+ return Ok(());
+ };
+
+ let _receipt = state
+ .access_service
+ .generate_entity_access_receipt::<EditAccessLevel>(
+ &user.macro_user_id,
+ user.user_context.organization_id.map(i64::from),
+ parent_id,
+ EntityType::Project,
+ )
+ .await
+ .map_err(|_| ProjectError::Unauthorized)?;
+ Ok(())
+}
+
+/// Mark a project tree as uploaded. This handler is mounted only on the internal router.
+#[tracing::instrument(skip(state, user, request), fields(user_id=%user.macro_user_id), err)]
+pub async fn mark_uploaded_handler<T, Svc, Auth>(
+ State(state): State<ProjectRouterState<T, Svc, Auth>>,
+ user: MacroAuthorizationExtractor<Auth>,
+ Json(request): Json<MarkProjectUploadedRequest>,
+) -> Result<Json<MarkProjectUploadedResponse>, ProjectError>
+where
+ T: ProjectService,
+ Svc: EntityAccessService,
+ Auth: MacroAuthorizationService,
+{
+ let project_ids = state
+ .service
+ .mark_projects_uploaded(&request.project_id)
+ .await?;
+ Ok(Json(MarkProjectUploadedResponse { project_ids }))
+}
diff --git a/crates/projects/src/lib.rs b/crates/projects/src/lib.rs
new file mode 100644
index 0000000000..aa54ea31f3
--- /dev/null
+++ b/crates/projects/src/lib.rs
@@ -0,0 +1,15 @@
+//! Projects hexagonal architecture crate.
+//!
+//! Encapsulates project operations using a ports-and-adapters architecture.
+//! The domain owns business policy, while inbound and outbound modules adapt
+//! transport and infrastructure concerns.
+
+#![deny(missing_docs)]
+
+pub mod domain;
+
+#[cfg(feature = "inbound")]
+pub mod inbound;
+
+#[cfg(feature = "outbound")]
+pub mod outbound;
diff --git a/crates/projects/src/outbound.rs b/crates/projects/src/outbound.rs
new file mode 100644
index 0000000000..c49dd7e5a1
--- /dev/null
+++ b/crates/projects/src/outbound.rs
@@ -0,0 +1,18 @@
+//! Outbound adapters for the projects domain.
+
+/// DynamoDB bulk-upload request adapter.
+pub mod dynamo_bulk_upload;
+/// PostgreSQL project repository.
+pub mod pg_project_repo;
+/// S3 project-upload URL adapter.
+pub mod s3_upload_urls;
+/// Redis content-hash counter adapter.
+pub mod sha_counter;
+/// SQS project search-index adapter.
+pub mod sqs_search_indexer;
+
+pub use dynamo_bulk_upload::DynamoBulkUploadAdapter;
+pub use pg_project_repo::PgProjectRepo;
+pub use s3_upload_urls::S3ProjectUploadAdapter;
+pub use sha_counter::ShaCountAdapter;
+pub use sqs_search_indexer::SqsProjectSearchIndexer;
diff --git a/crates/projects/src/outbound/dynamo_bulk_upload.rs b/crates/projects/src/outbound/dynamo_bulk_upload.rs
new file mode 100644
index 0000000000..1da527ec6b
--- /dev/null
+++ b/crates/projects/src/outbound/dynamo_bulk_upload.rs
@@ -0,0 +1,45 @@
+//! DynamoDB adapter for project bulk-upload requests.
+
+use crate::domain::ports::BulkUploadRequestPort;
+use models_bulk_upload::{BulkUploadRequest, BulkUploadRequestDocuments};
+use uuid::Uuid;
+
+/// DynamoDB-backed bulk-upload request adapter.
+#[derive(Clone, Debug)]
+pub struct DynamoBulkUploadAdapter {
+ client: dynamodb_client::DynamodbClient,
+}
+
+impl DynamoBulkUploadAdapter {
+ /// Create a bulk-upload adapter from a DynamoDB client.
+ pub fn new(client: dynamodb_client::DynamodbClient) -> Self {
+ Self { client }
+ }
+}
+
+impl BulkUploadRequestPort for DynamoBulkUploadAdapter {
+ #[tracing::instrument(skip(self), err)]
+ async fn create_bulk_upload_request(
+ &self,
+ request_id: Uuid,
+ user_id: &str,
+ name: Option<&str>,
+ parent_id: Option<&str>,
+ ) -> anyhow::Result<BulkUploadRequest> {
+ self.client
+ .bulk_upload
+ .create_bulk_upload_request(&request_id.to_string(), user_id, name, parent_id)
+ .await
+ }
+
+ #[tracing::instrument(skip(self), err)]
+ async fn get_bulk_upload_document_statuses(
+ &self,
+ upload_request_id: &str,
+ ) -> anyhow::Result<BulkUploadRequestDocuments> {
+ self.client
+ .bulk_upload
+ .get_bulk_upload_document_statuses(upload_request_id)
+ .await
+ }
+}
diff --git a/crates/projects/src/outbound/pg_project_repo.rs b/crates/projects/src/outbound/pg_project_repo.rs
new file mode 100644
index 0000000000..f59c2e781e
--- /dev/null
+++ b/crates/projects/src/outbound/pg_project_repo.rs
@@ -0,0 +1,346 @@
+//! PostgreSQL implementation of the [`ProjectRepo`] port.
+
+mod content;
+mod create;
+mod delete;
+mod edit;
+mod revert_delete;
+mod share;
+mod upload_folder;
+
+#[cfg(test)]
+mod tests;
+
+use std::collections::HashMap;
+
+use macro_user_id::{cowlike::CowLike, user_id::MacroUserIdStr};
+use model::project::{
+ BasicProject, Project, ProjectPreviewData, ProjectPreviewV2, ProjectWithUploadRequest,
+ WithProjectId,
+};
+use sqlx::PgPool;
+
+use crate::domain::models::{
+ CreateProjectArgs, EditProjectArgs, PurgedProjectTree, RevertDeleteResult, SoftDeleteResult,
+ UploadFolderRepoArgs,
+};
+use crate::domain::ports::ProjectRepo;
+
+/// PostgreSQL-backed project repository.
+#[derive(Clone)]
+pub struct PgProjectRepo {
+ pool: PgPool,
+}
+
+impl PgProjectRepo {
+ /// Create a repository backed by the given connection pool.
+ pub fn new(pool: PgPool) -> Self {
+ Self { pool }
+ }
+}
+
+impl ProjectRepo for PgProjectRepo {
+ type Err = sqlx::Error;
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_basic_project(&self, project_id: &str) -> Result<Option<BasicProject>, Self::Err> {
+ sqlx::query!(
+ r#"
+ SELECT
+ p.id,
+ p."userId" AS "user_id",
+ p.name,
+ p."parentId" AS "parent_id",
+ p."deletedAt"::timestamptz AS "deleted_at"
+ FROM "Project" p
+ WHERE p.id = $1
+ "#,
+ project_id,
+ )
+ .try_map(|row| {
+ Ok(BasicProject {
+ id: row.id,
+ user_id: MacroUserIdStr::parse_from_str(&row.user_id)
+ .map_err(|error| sqlx::Error::Decode(Box::new(error)))?
+ .into_owned(),
+ parent_id: row.parent_id,
+ name: row.name,
+ deleted_at: row.deleted_at,
+ })
+ })
+ .fetch_optional(&self.pool)
+ .await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_project_by_id(&self, project_id: &str) -> Result<Option<Project>, Self::Err> {
+ sqlx::query_as!(
+ Project,
+ r#"
+ SELECT
+ p.id,
+ p.name,
+ p."userId" AS "user_id",
+ p."parentId" AS "parent_id",
+ p."createdAt"::timestamptz AS "created_at",
+ p."updatedAt"::timestamptz AS "updated_at",
+ p."deletedAt"::timestamptz AS "deleted_at"
+ FROM "Project" p
+ WHERE p.id = $1 AND p."deletedAt" IS NULL
+ "#,
+ project_id,
+ )
+ .fetch_optional(&self.pool)
+ .await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_projects_for_user(&self, user_id: &str) -> Result<Vec<Project>, Self::Err> {
+ sqlx::query_as!(
+ Project,
+ r#"
+ SELECT
+ p.id,
+ p.name,
+ p."userId" AS "user_id",
+ p."parentId" AS "parent_id",
+ p."createdAt"::timestamptz AS "created_at",
+ p."updatedAt"::timestamptz AS "updated_at",
+ p."deletedAt"::timestamptz AS "deleted_at"
+ FROM "UserHistory" history
+ INNER JOIN "Project" p
+ ON history."itemId" = p.id AND history."itemType" = 'project'
+ WHERE history."userId" = $1
+ AND p."deletedAt" IS NULL
+ AND p."uploadPending" = false
+ ORDER BY p."updatedAt" DESC
+ "#,
+ user_id,
+ )
+ .fetch_all(&self.pool)
+ .await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_pending_root_projects(
+ &self,
+ user_id: &str,
+ ) -> Result<Vec<ProjectWithUploadRequest>, Self::Err> {
+ sqlx::query!(
+ r#"
+ SELECT
+ p.id,
+ p.name,
+ p."userId" AS "user_id",
+ p."parentId" AS "parent_id",
+ p."createdAt"::timestamptz AS "created_at",
+ p."updatedAt"::timestamptz AS "updated_at",
+ p."uploadRequestId" AS "upload_request_id"
+ FROM "Project" p
+ WHERE p."userId" = $1
+ AND p."deletedAt" IS NULL
+ AND p."uploadPending" = true
+ AND p."parentId" IS NULL
+ ORDER BY p."updatedAt" DESC
+ "#,
+ user_id,
+ )
+ .map(|row| ProjectWithUploadRequest {
+ project: Project {
+ id: row.id,
+ name: row.name,
+ user_id: row.user_id,
+ parent_id: row.parent_id,
+ created_at: row.created_at,
+ updated_at: row.updated_at,
+ deleted_at: None,
+ },
+ upload_request_id: row.upload_request_id,
+ })
+ .fetch_all(&self.pool)
+ .await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_project_children(
+ &self,
+ project_id: &str,
+ ) -> Result<Vec<model::item::Item>, Self::Err> {
+ content::get_project_children(&self.pool, project_id).await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn get_project_share_permission(
+ &self,
+ project_id: &str,
+ ) -> Result<models_permissions::share_permission::SharePermissionV2, Self::Err> {
+ share::get_project_share_permission(&self.pool, project_id).await
+ }
+
+ #[tracing::instrument(err, skip(self, project_ids))]
+ async fn batch_get_project_preview(
+ &self,
+ project_ids: &[String],
+ ) -> Result<Vec<ProjectPreviewV2>, Self::Err> {
+ let found = sqlx::query_as!(
+ ProjectPreviewData,
+ r#"
+ WITH RECURSIVE project_path AS (
+ SELECT
+ p.id,
+ p.name,
+ p."userId",
+ p."parentId",
+ p."updatedAt",
+ ARRAY[p.name] AS path
+ FROM "Project" p
+ WHERE p.id = ANY($1)
+
+ UNION ALL
+
+ SELECT
+ child.id,
+ child.name,
+ child."userId",
+ parent."parentId",
+ child."updatedAt",
+ ARRAY[parent.name] || child.path AS path
+ FROM project_path child
+ JOIN "Project" parent ON child."parentId" = parent.id
+ )
+ SELECT DISTINCT ON (id)
+ id AS "id!",
+ name AS "name!",
+ "userId" AS "owner!",
+ path AS "path!",
+ "updatedAt"::timestamptz AS "updated_at"
+ FROM project_path
+ WHERE "parentId" IS NULL
+ ORDER BY id
+ "#,
+ project_ids,
+ )
+ .fetch_all(&self.pool)
+ .await?;
+
+ let found_by_id: HashMap<&str, &ProjectPreviewData> = found
+ .iter()
+ .map(|project| (project.id.as_str(), project))
+ .collect();
+ Ok(project_ids
+ .iter()
+ .map(|id| match found_by_id.get(id.as_str()) {
+ Some(project) => ProjectPreviewV2::Found((*project).clone()),
+ None => ProjectPreviewV2::DoesNotExist(WithProjectId { id: id.clone() }),
+ })
+ .collect())
+ }
+
+ #[tracing::instrument(err, skip(self, args))]
+ async fn create_project(&self, args: CreateProjectArgs) -> Result<Project, Self::Err> {
+ let mut transaction = self.pool.begin().await?;
+ let project = create::create_project(&mut transaction, &args).await?;
+ transaction.commit().await?;
+ Ok(project)
+ }
+
+ #[tracing::instrument(err, skip(self, args))]
+ async fn edit_project(&self, args: EditProjectArgs) -> Result<Project, Self::Err> {
+ let mut transaction = self.pool.begin().await?;
+ let project = edit::edit_project(&mut transaction, &args).await?;
+ transaction.commit().await?;
+ Ok(project)
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn is_project_recursively_nested(
+ &self,
+ project_id: &str,
+ parent_id: &str,
+ ) -> Result<bool, Self::Err> {
+ let mut transaction = self.pool.begin().await?;
+ edit::is_project_recursively_nested(&mut transaction, project_id, parent_id).await
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn soft_delete_project(&self, project_id: &str) -> Result<SoftDeleteResult, Self::Err> {
+ let mut transaction = self.pool.begin().await?;
+ let result = delete::soft_delete_project(&mut transaction, project_id).await?;
+ transaction.commit().await?;
+ Ok(result)
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn purge_deleted_project_tree(
+ &self,
+ project_id: &str,
+ ) -> Result<PurgedProjectTree, Self::Err> {
+ let mut transaction = self.pool.begin().await?;
+ let result = delete::purge_deleted_project_tree(&mut transaction, project_id).await?;
+ transaction.commit().await?;
+ Ok(result)
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn revert_delete_project(
+ &self,
+ project_id: &str,
+ previous_parent_id: Option<String>,
+ ) -> Result<RevertDeleteResult, Self::Err> {
+ let mut transaction = self.pool.begin().await?;
+ let result = revert_delete::revert_delete_project(
+ &mut transaction,
+ project_id,
+ previous_parent_id.as_deref(),
+ )
+ .await?;
+ transaction.commit().await?;
+ Ok(result)
+ }
+
+ #[tracing::instrument(err, skip(self, args))]
+ async fn upload_folder(
+ &self,
+ args: UploadFolderRepoArgs,
+ ) -> Result<model::folder::UploadFolderWithIdsResponse, Self::Err> {
+ let mut transaction = self.pool.begin().await?;
+ let result = upload_folder::upload_folder(&mut transaction, args).await?;
+ transaction.commit().await?;
+ Ok(result)
+ }
+
+ #[tracing::instrument(err, skip(self, project_ids, document_ids))]
+ async fn delete_uploaded_tree(
+ &self,
+ project_ids: &[String],
+ document_ids: &[String],
+ ) -> Result<(), Self::Err> {
+ let mut transaction = self.pool.begin().await?;
+ delete::delete_uploaded_tree(&mut transaction, project_ids, document_ids).await?;
+ transaction.commit().await?;
+ Ok(())
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn mark_projects_uploaded(
+ &self,
+ root_project_id: &str,
+ ) -> Result<Vec<String>, Self::Err> {
+ let mut transaction = self.pool.begin().await?;
+ let project_ids =
+ upload_folder::mark_projects_uploaded(&mut transaction, root_project_id).await?;
+ transaction.commit().await?;
+ Ok(project_ids)
+ }
+
+ #[tracing::instrument(err, skip(self))]
+ async fn update_project_modified(&self, project_id: &str) -> Result<(), Self::Err> {
+ sqlx::query!(
+ r#"UPDATE "Project" SET "updatedAt" = NOW() WHERE id = $1"#,
+ project_id,
+ )
+ .execute(&self.pool)
+ .await?;
+ Ok(())
+ }
+}
diff --git a/crates/projects/src/outbound/pg_project_repo/content.rs b/crates/projects/src/outbound/pg_project_repo/content.rs
new file mode 100644
index 0000000000..ba0cf36922
--- /dev/null
+++ b/crates/projects/src/outbound/pg_project_repo/content.rs
@@ -0,0 +1,148 @@
+use document_sub_type::DocumentSubType;
+use macro_user_id::{cowlike::CowLike, user_id::MacroUserIdStr};
+use model::chat::Chat;
+use model::document::{BasicDocument, BasicDocumentSubType};
+use model::item::Item;
+use model::project::Project;
+use sqlx::PgPool;
+use system_properties::{StatusOption, SystemPropertyKey};
+
+pub(super) async fn get_project_children(
+ pool: &PgPool,
+ project_id: &str,
+) -> Result<Vec<Item>, sqlx::Error> {
+ let projects = get_sub_projects(pool, project_id).await?;
+ let documents = get_sub_documents(pool, project_id).await?;
+ let chats = get_sub_chats(pool, project_id).await?;
+
+ let mut children = Vec::with_capacity(projects.len() + documents.len() + chats.len());
+ children.extend(projects.into_iter().map(Item::Project));
+ children.extend(documents.into_iter().map(Item::Document));
+ children.extend(chats.into_iter().map(Item::Chat));
+ Ok(children)
+}
+
+async fn get_sub_projects(pool: &PgPool, project_id: &str) -> Result<Vec<Project>, sqlx::Error> {
+ sqlx::query_as!(
+ Project,
+ r#"
+ SELECT
+ p.id,
+ p.name,
+ p."userId" AS "user_id",
+ p."parentId" AS "parent_id?",
+ p."createdAt"::timestamptz AS "created_at",
+ p."updatedAt"::timestamptz AS "updated_at",
+ p."deletedAt"::timestamptz AS "deleted_at"
+ FROM "Project" p
+ WHERE p."parentId" = $1 AND p."deletedAt" IS NULL
+ ORDER BY p."createdAt" ASC, p.id ASC
+ "#,
+ project_id,
+ )
+ .fetch_all(pool)
+ .await
+}
+
+async fn get_sub_documents(
+ pool: &PgPool,
+ project_id: &str,
+) -> Result<Vec<BasicDocument>, sqlx::Error> {
+ let completed_option_id = StatusOption::COMPLETED_UUID.to_string();
+ let status_property_id = SystemPropertyKey::STATUS_UUID;
+
+ sqlx::query!(
+ r#"
+ SELECT
+ d.id AS "document_id",
+ d.owner,
+ d.name AS "document_name",
+ COALESCE(bom.id, instance.id) AS "document_version_id!",
+ d."fileType" AS "file_type?",
+ d."createdAt"::timestamptz AS "created_at",
+ d."updatedAt"::timestamptz AS "updated_at",
+ d."projectId" AS "project_id?",
+ subtype.sub_type AS "sub_type?: DocumentSubType",
+ CASE
+ WHEN subtype.sub_type = 'task'
+ AND status.values->'value' ? $2
+ THEN true
+ WHEN subtype.sub_type = 'task' THEN false
+ ELSE NULL
+ END AS "is_completed"
+ FROM "Document" d
+ LEFT JOIN document_sub_type subtype ON subtype.document_id = d.id
+ LEFT JOIN entity_properties status
+ ON subtype.sub_type = 'task'
+ AND status.entity_id = d.id
+ AND status.entity_type = 'TASK'
+ AND status.property_definition_id = $3
+ LEFT JOIN LATERAL (
+ SELECT b.id
+ FROM "DocumentBom" b
+ WHERE b."documentId" = d.id
+ ORDER BY b."createdAt" DESC
+ LIMIT 1
+ ) bom ON d."fileType" = 'docx'
+ LEFT JOIN LATERAL (
+ SELECT i.id
+ FROM "DocumentInstance" i
+ WHERE i."documentId" = d.id
+ ORDER BY i."updatedAt" DESC
+ LIMIT 1
+ ) instance ON d."fileType" IS DISTINCT FROM 'docx'
+ WHERE d."projectId" = $1 AND d."deletedAt" IS NULL
+ ORDER BY d."createdAt" ASC, d.id ASC
+ "#,
+ project_id,
+ completed_option_id,
+ status_property_id,
+ )
+ .try_map(|row| {
+ Ok(BasicDocument {
+ document_id: row.document_id,
+ document_version_id: row.document_version_id,
+ owner: MacroUserIdStr::parse_from_str(&row.owner)
+ .map_err(|error| sqlx::Error::Decode(Box::new(error)))?
+ .into_owned(),
+ document_name: row.document_name,
+ file_type: row.file_type,
+ project_id: row.project_id,
+ sha: None,
+ branched_from_id: None,
+ branched_from_version_id: None,
+ document_family_id: None,
+ created_at: row.created_at,
+ updated_at: row.updated_at,
+ deleted_at: None,
+ sub_type: BasicDocumentSubType::from_db(row.sub_type, row.is_completed),
+ })
+ })
+ .fetch_all(pool)
+ .await
+}
+
+async fn get_sub_chats(pool: &PgPool, project_id: &str) -> Result<Vec<Chat>, sqlx::Error> {
+ sqlx::query_as!(
+ Chat,
+ r#"
+ SELECT
+ c.id,
+ c.name,
+ c."userId" AS "user_id",
+ c.model AS "model?",
+ c."projectId" AS "project_id?",
+ c."tokenCount" AS "token_count",
+ c."createdAt"::timestamptz AS "created_at",
+ c."updatedAt"::timestamptz AS "updated_at",
+ c."deletedAt"::timestamptz AS "deleted_at",
+ c."isPersistent" AS "is_persistent"
+ FROM "Chat" c
+ WHERE c."projectId" = $1 AND c."deletedAt" IS NULL
+ ORDER BY c."createdAt" ASC, c.id ASC
+ "#,
+ project_id,
+ )
+ .fetch_all(pool)
+ .await
+}
diff --git a/crates/projects/src/outbound/pg_project_repo/create.rs b/crates/projects/src/outbound/pg_project_repo/create.rs
new file mode 100644
index 0000000000..b1df0242e7
--- /dev/null
+++ b/crates/projects/src/outbound/pg_project_repo/create.rs
@@ -0,0 +1,67 @@
+use entity_access_db_utils::{
+ AccessLevel, EntityAccessSourceType, EntityType, insert_entity_access_row,
+};
+use model::project::Project;
+use sqlx::{Postgres, Transaction};
+
+use crate::domain::models::CreateProjectArgs;
+
+use super::share;
+
+pub(super) async fn create_project(
+ transaction: &mut Transaction<'_, Postgres>,
+ args: &CreateProjectArgs,
+) -> Result<Project, sqlx::Error> {
+ let project = sqlx::query_as!(
+ Project,
+ r#"
+ INSERT INTO "Project" (name, "userId", "parentId", "createdAt", "updatedAt")
+ VALUES ($1, $2, $3, NOW(), NOW())
+ RETURNING
+ id,
+ name,
+ "userId" AS user_id,
+ "parentId" AS parent_id,
+ "createdAt"::timestamptz AS created_at,
+ "updatedAt"::timestamptz AS updated_at,
+ "deletedAt"::timestamptz AS deleted_at
+ "#,
+ args.name,
+ args.user_id,
+ args.parent_id,
+ )
+ .fetch_one(transaction.as_mut())
+ .await?;
+
+ share::create_project_share_permission(transaction, &project.id, &args.share_permission)
+ .await?;
+
+ sqlx::query!(
+ r#"
+ INSERT INTO "UserHistory" ("userId", "itemId", "itemType", "createdAt", "updatedAt")
+ VALUES ($1, $2, 'project', NOW(), NOW())
+ ON CONFLICT ("userId", "itemId", "itemType") DO UPDATE
+ SET "updatedAt" = NOW()
+ "#,
+ args.user_id,
+ project.id,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+
+ let project_id = project
+ .id
+ .parse()
+ .map_err(|error| sqlx::Error::Decode(Box::new(error)))?;
+ insert_entity_access_row(
+ transaction,
+ &project_id,
+ EntityType::Project,
+ &args.user_id,
+ EntityAccessSourceType::User,
+ AccessLevel::Owner,
+ )
+ .await?;
+
+ Ok(project)
+}
diff --git a/crates/projects/src/outbound/pg_project_repo/delete.rs b/crates/projects/src/outbound/pg_project_repo/delete.rs
new file mode 100644
index 0000000000..0458723d07
--- /dev/null
+++ b/crates/projects/src/outbound/pg_project_repo/delete.rs
@@ -0,0 +1,235 @@
+use chrono::Utc;
+use sqlx::{Postgres, Transaction};
+
+use crate::domain::models::{PurgedProjectTree, SoftDeleteResult};
+
+pub(super) async fn purge_deleted_project_tree(
+ transaction: &mut Transaction<'_, Postgres>,
+ project_id: &str,
+) -> Result<PurgedProjectTree, sqlx::Error> {
+ let project_ids = sqlx::query_scalar!(
+ r#"
+ WITH RECURSIVE project_hierarchy AS (
+ SELECT id
+ FROM "Project"
+ WHERE id = $1 AND "deletedAt" IS NOT NULL
+ UNION ALL
+ SELECT child.id
+ FROM "Project" child
+ JOIN project_hierarchy parent ON child."parentId" = parent.id
+ WHERE child."deletedAt" IS NOT NULL
+ )
+ SELECT id AS "id!" FROM project_hierarchy
+ "#,
+ project_id,
+ )
+ .fetch_all(transaction.as_mut())
+ .await?;
+
+ let documents = sqlx::query!(
+ r#"
+ SELECT id, owner
+ FROM "Document"
+ WHERE "projectId" = ANY($1) AND "deletedAt" IS NOT NULL
+ "#,
+ &project_ids,
+ )
+ .map(|row| (row.id, row.owner))
+ .fetch_all(transaction.as_mut())
+ .await?;
+ let document_ids = documents
+ .iter()
+ .map(|(id, _)| id.clone())
+ .collect::<Vec<_>>();
+ let chat_ids = sqlx::query_scalar!(
+ r#"
+ SELECT id
+ FROM "Chat"
+ WHERE "projectId" = ANY($1) AND "deletedAt" IS NOT NULL
+ "#,
+ &project_ids,
+ )
+ .fetch_all(transaction.as_mut())
+ .await?;
+ let bom_shas = sqlx::query!(
+ r#"
+ SELECT part.sha, COUNT(*) AS "count!"
+ FROM "BomPart" part
+ JOIN "DocumentBom" bom ON bom.id = part."documentBomId"
+ WHERE bom."documentId" = ANY($1)
+ GROUP BY part.sha
+ ORDER BY part.sha
+ "#,
+ &document_ids,
+ )
+ .map(|row| (row.sha, row.count))
+ .fetch_all(transaction.as_mut())
+ .await?;
+
+ delete_items(transaction, &project_ids, &document_ids, &chat_ids).await?;
+
+ Ok(PurgedProjectTree {
+ project_ids,
+ chat_ids,
+ documents,
+ bom_shas,
+ })
+}
+
+pub(super) async fn delete_uploaded_tree(
+ transaction: &mut Transaction<'_, Postgres>,
+ project_ids: &[String],
+ document_ids: &[String],
+) -> Result<(), sqlx::Error> {
+ delete_items(transaction, project_ids, document_ids, &[]).await
+}
+
+async fn delete_items(
+ transaction: &mut Transaction<'_, Postgres>,
+ project_ids: &[String],
+ document_ids: &[String],
+ chat_ids: &[String],
+) -> Result<(), sqlx::Error> {
+ let all_ids = project_ids
+ .iter()
+ .chain(document_ids)
+ .chain(chat_ids)
+ .cloned()
+ .collect::<Vec<_>>();
+
+ sqlx::query!(
+ r#"DELETE FROM "Pin" WHERE "pinnedItemId" = ANY($1)"#,
+ &all_ids
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(
+ r#"DELETE FROM "UserHistory" WHERE "itemId" = ANY($1)"#,
+ &all_ids
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(
+ r#"
+ DELETE FROM "SharePermission"
+ WHERE id IN (
+ SELECT "sharePermissionId" FROM "ProjectPermission" WHERE "projectId" = ANY($1)
+ UNION
+ SELECT "sharePermissionId" FROM "DocumentPermission" WHERE "documentId" = ANY($2)
+ UNION
+ SELECT "sharePermissionId" FROM "ChatPermission" WHERE "chatId" = ANY($3)
+ )
+ "#,
+ project_ids,
+ document_ids,
+ chat_ids,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(
+ r#"
+ DELETE FROM entity_access
+ WHERE entity_id::text = ANY($1)
+ OR "granted_from_project_id" = ANY($2)
+ "#,
+ &all_ids,
+ project_ids,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(r#"DELETE FROM "Document" WHERE id = ANY($1)"#, document_ids)
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(r#"DELETE FROM "Chat" WHERE id = ANY($1)"#, chat_ids)
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(r#"DELETE FROM "Project" WHERE id = ANY($1)"#, project_ids)
+ .execute(transaction.as_mut())
+ .await?;
+ Ok(())
+}
+
+pub(super) async fn soft_delete_project(
+ transaction: &mut Transaction<'_, Postgres>,
+ project_id: &str,
+) -> Result<SoftDeleteResult, sqlx::Error> {
+ let project_ids = sqlx::query_scalar!(
+ r#"
+ WITH RECURSIVE project_hierarchy AS (
+ SELECT id FROM "Project" WHERE id = $1 AND "deletedAt" IS NULL
+ UNION ALL
+ SELECT child.id
+ FROM "Project" child
+ JOIN project_hierarchy parent ON child."parentId" = parent.id
+ WHERE child."deletedAt" IS NULL
+ )
+ SELECT id AS "id!" FROM project_hierarchy
+ "#,
+ project_id,
+ )
+ .fetch_all(transaction.as_mut())
+ .await?;
+
+ // Unlike the legacy implementation, child reads use the same transaction
+ // as the writes. This intentionally removes read skew during concurrent moves.
+ let document_ids = sqlx::query_scalar!(
+ r#"SELECT id FROM "Document" WHERE "projectId" = ANY($1)"#,
+ &project_ids,
+ )
+ .fetch_all(transaction.as_mut())
+ .await?;
+ let chat_ids = sqlx::query_scalar!(
+ r#"SELECT id FROM "Chat" WHERE "projectId" = ANY($1)"#,
+ &project_ids,
+ )
+ .fetch_all(transaction.as_mut())
+ .await?;
+
+ let all_ids = project_ids
+ .iter()
+ .chain(&document_ids)
+ .chain(&chat_ids)
+ .cloned()
+ .collect::<Vec<_>>();
+ sqlx::query!(
+ r#"DELETE FROM "Pin" WHERE "pinnedItemId" = ANY($1)"#,
+ &all_ids
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(
+ r#"DELETE FROM "UserHistory" WHERE "itemId" = ANY($1)"#,
+ &all_ids,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+
+ let deleted_at = Utc::now().naive_utc();
+ sqlx::query!(
+ r#"UPDATE "Document" SET "deletedAt" = $2 WHERE id = ANY($1)"#,
+ &document_ids,
+ deleted_at,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(
+ r#"UPDATE "Chat" SET "deletedAt" = $2 WHERE id = ANY($1)"#,
+ &chat_ids,
+ deleted_at,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(
+ r#"UPDATE "Project" SET "deletedAt" = $2 WHERE id = ANY($1)"#,
+ &project_ids,
+ deleted_at,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+
+ Ok(SoftDeleteResult {
+ project_ids,
+ document_ids,
+ chat_ids,
+ })
+}
diff --git a/crates/projects/src/outbound/pg_project_repo/edit.rs b/crates/projects/src/outbound/pg_project_repo/edit.rs
new file mode 100644
index 0000000000..f65eae93bb
--- /dev/null
+++ b/crates/projects/src/outbound/pg_project_repo/edit.rs
@@ -0,0 +1,69 @@
+use model::project::Project;
+use sqlx::{Postgres, Transaction};
+
+use crate::domain::models::EditProjectArgs;
+
+use super::share;
+
+pub(super) async fn edit_project(
+ transaction: &mut Transaction<'_, Postgres>,
+ args: &EditProjectArgs,
+) -> Result<Project, sqlx::Error> {
+ // Separate flags make all three parent states compile checked: unchanged,
+ // set to an ID, and explicitly cleared to NULL.
+ let project = sqlx::query_as!(
+ Project,
+ r#"
+ UPDATE "Project"
+ SET
+ name = CASE WHEN $2 THEN $3 ELSE name END,
+ "parentId" = CASE WHEN $4 THEN $5 ELSE "parentId" END,
+ "updatedAt" = NOW()
+ WHERE id = $1
+ RETURNING
+ id,
+ name,
+ "userId" AS user_id,
+ "parentId" AS parent_id,
+ "createdAt"::timestamptz AS created_at,
+ "updatedAt"::timestamptz AS updated_at,
+ "deletedAt"::timestamptz AS deleted_at
+ "#,
+ args.project_id,
+ args.name.is_some(),
+ args.name,
+ args.update_parent,
+ args.parent_id,
+ )
+ .fetch_one(transaction.as_mut())
+ .await?;
+
+ if let Some(permission) = args.share_permission.as_ref() {
+ share::edit_project_share_permission(transaction, &args.project_id, permission).await?;
+ }
+ Ok(project)
+}
+
+pub(super) async fn is_project_recursively_nested(
+ transaction: &mut Transaction<'_, Postgres>,
+ project_id: &str,
+ parent_id: &str,
+) -> Result<bool, sqlx::Error> {
+ sqlx::query_scalar!(
+ r#"
+ WITH RECURSIVE descendants AS (
+ SELECT id FROM "Project" WHERE "parentId" = $1 AND "deletedAt" IS NULL
+ UNION ALL
+ SELECT child.id
+ FROM "Project" child
+ JOIN descendants parent ON child."parentId" = parent.id
+ WHERE child."deletedAt" IS NULL
+ )
+ SELECT ($1 = $2) OR EXISTS(SELECT 1 FROM descendants WHERE id = $2) AS "exists!"
+ "#,
+ project_id,
+ parent_id,
+ )
+ .fetch_one(transaction.as_mut())
+ .await
+}
diff --git a/crates/projects/src/outbound/pg_project_repo/revert_delete.rs b/crates/projects/src/outbound/pg_project_repo/revert_delete.rs
new file mode 100644
index 0000000000..543f0092dc
--- /dev/null
+++ b/crates/projects/src/outbound/pg_project_repo/revert_delete.rs
@@ -0,0 +1,143 @@
+use sqlx::{Postgres, Transaction};
+
+use crate::domain::models::RevertDeleteResult;
+
+pub(super) async fn revert_delete_project(
+ transaction: &mut Transaction<'_, Postgres>,
+ project_id: &str,
+ previous_parent_id: Option<&str>,
+) -> Result<RevertDeleteResult, sqlx::Error> {
+ let projects = sqlx::query!(
+ r#"
+ WITH RECURSIVE project_hierarchy AS (
+ SELECT id, "userId" AS user_id
+ FROM "Project" WHERE id = $1 AND "deletedAt" IS NOT NULL
+ UNION ALL
+ SELECT child.id, child."userId" AS user_id
+ FROM "Project" child
+ JOIN project_hierarchy parent ON child."parentId" = parent.id
+ WHERE child."deletedAt" IS NOT NULL
+ )
+ SELECT id AS "id!", user_id AS "user_id!" FROM project_hierarchy
+ "#,
+ project_id,
+ )
+ .fetch_all(transaction.as_mut())
+ .await?;
+ let project_ids = projects
+ .iter()
+ .map(|row| row.id.clone())
+ .collect::<Vec<_>>();
+ let project_owner_ids = projects
+ .iter()
+ .map(|row| row.user_id.clone())
+ .collect::<Vec<_>>();
+
+ // Child reads deliberately remain inside this transaction so restoration
+ // observes one consistent subtree rather than the legacy read-skew window.
+ let documents = sqlx::query!(
+ r#"
+ SELECT id, owner FROM "Document"
+ WHERE "projectId" = ANY($1) AND "deletedAt" IS NOT NULL
+ "#,
+ &project_ids,
+ )
+ .fetch_all(transaction.as_mut())
+ .await?;
+ let chats = sqlx::query!(
+ r#"
+ SELECT id, "userId" AS user_id FROM "Chat"
+ WHERE "projectId" = ANY($1) AND "deletedAt" IS NOT NULL
+ "#,
+ &project_ids,
+ )
+ .fetch_all(transaction.as_mut())
+ .await?;
+ let document_ids = documents
+ .iter()
+ .map(|row| row.id.clone())
+ .collect::<Vec<_>>();
+ let document_owner_ids = documents
+ .iter()
+ .map(|row| row.owner.clone())
+ .collect::<Vec<_>>();
+ let chat_ids = chats.iter().map(|row| row.id.clone()).collect::<Vec<_>>();
+ let chat_owner_ids = chats
+ .iter()
+ .map(|row| row.user_id.clone())
+ .collect::<Vec<_>>();
+
+ restore_items(transaction, "chat", &chat_ids, &chat_owner_ids).await?;
+ restore_items(transaction, "document", &document_ids, &document_owner_ids).await?;
+ restore_items(transaction, "project", &project_ids, &project_owner_ids).await?;
+
+ if let Some(parent_id) = previous_parent_id {
+ let parent_is_deleted = sqlx::query_scalar!(
+ r#"SELECT "deletedAt" IS NOT NULL AS "is_deleted!" FROM "Project" WHERE id = $1"#,
+ parent_id,
+ )
+ .fetch_optional(transaction.as_mut())
+ .await?
+ .unwrap_or(false);
+ if parent_is_deleted {
+ sqlx::query!(
+ r#"UPDATE "Project" SET "parentId" = NULL WHERE id = $1"#,
+ project_id,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ }
+ }
+
+ Ok(RevertDeleteResult { project_ids })
+}
+
+async fn restore_items(
+ transaction: &mut Transaction<'_, Postgres>,
+ item_type: &str,
+ item_ids: &[String],
+ owner_ids: &[String],
+) -> Result<(), sqlx::Error> {
+ match item_type {
+ "chat" => {
+ sqlx::query!(
+ r#"UPDATE "Chat" SET "deletedAt" = NULL WHERE id = ANY($1)"#,
+ item_ids
+ )
+ .execute(transaction.as_mut())
+ .await?
+ }
+ "document" => {
+ sqlx::query!(
+ r#"UPDATE "Document" SET "deletedAt" = NULL WHERE id = ANY($1)"#,
+ item_ids
+ )
+ .execute(transaction.as_mut())
+ .await?
+ }
+ "project" => {
+ sqlx::query!(
+ r#"UPDATE "Project" SET "deletedAt" = NULL WHERE id = ANY($1)"#,
+ item_ids
+ )
+ .execute(transaction.as_mut())
+ .await?
+ }
+ _ => unreachable!("known item type"),
+ };
+ sqlx::query!(
+ r#"
+ INSERT INTO "UserHistory" ("userId", "itemId", "itemType", "createdAt", "updatedAt")
+ SELECT value.owner_id, value.item_id, $3, NOW(), NOW()
+ FROM UNNEST($1::text[], $2::text[]) AS value(item_id, owner_id)
+ ON CONFLICT ("userId", "itemId", "itemType") DO UPDATE
+ SET "updatedAt" = NOW()
+ "#,
+ item_ids,
+ owner_ids,
+ item_type,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ Ok(())
+}
diff --git a/crates/projects/src/outbound/pg_project_repo/share.rs b/crates/projects/src/outbound/pg_project_repo/share.rs
new file mode 100644
index 0000000000..690f2be032
--- /dev/null
+++ b/crates/projects/src/outbound/pg_project_repo/share.rs
@@ -0,0 +1,218 @@
+use std::str::FromStr;
+
+use entity_access_db_utils::EntityType;
+use models_permissions::share_permission::channel_share_permission::{
+ ChannelSharePermission, UpdateOperation,
+};
+use models_permissions::share_permission::{
+ SharePermissionV2, UpdateSharePermissionRequestV2, access_level::AccessLevel,
+};
+use sqlx::{PgPool, Postgres, Transaction};
+
+pub(super) async fn get_project_share_permission(
+ pool: &PgPool,
+ project_id: &str,
+) -> Result<SharePermissionV2, sqlx::Error> {
+ let row = sqlx::query!(
+ r#"
+ SELECT
+ permission.id,
+ permission."isPublic" AS "is_public",
+ permission."publicAccessLevel" AS "public_access_level?",
+ project."userId" AS owner,
+ COALESCE(
+ json_agg(json_build_object(
+ 'channel_id', channel."channel_id",
+ 'access_level', channel."access_level"
+ )) FILTER (WHERE channel."channel_id" IS NOT NULL),
+ '[]'
+ ) AS "channel_share_permissions?"
+ FROM "ProjectPermission" project_permission
+ JOIN "SharePermission" permission
+ ON project_permission."sharePermissionId" = permission.id
+ JOIN "Project" project ON project_permission."projectId" = project.id
+ LEFT JOIN "ChannelSharePermission" channel
+ ON channel."share_permission_id" = permission.id
+ WHERE project_permission."projectId" = $1
+ GROUP BY permission.id, project."userId"
+ "#,
+ project_id,
+ )
+ .fetch_one(pool)
+ .await?;
+
+ let channel_share_permissions = row
+ .channel_share_permissions
+ .map(serde_json::from_value::<Vec<ChannelSharePermission>>)
+ .transpose()
+ .map_err(|error| sqlx::Error::Decode(Box::new(error)))?
+ .filter(|permissions| !permissions.is_empty());
+ let public_access_level = row
+ .public_access_level
+ .map(|level| {
+ AccessLevel::from_str(&level).map_err(|error| sqlx::Error::Decode(Box::new(error)))
+ })
+ .transpose()?;
+
+ Ok(SharePermissionV2 {
+ id: row.id,
+ is_public: row.is_public,
+ public_access_level,
+ owner: row.owner,
+ channel_share_permissions,
+ })
+}
+
+pub(super) async fn create_project_share_permission(
+ transaction: &mut Transaction<'_, Postgres>,
+ project_id: &str,
+ permission: &SharePermissionV2,
+) -> Result<(), sqlx::Error> {
+ let row = sqlx::query!(
+ r#"
+ INSERT INTO "SharePermission" ("isPublic", "publicAccessLevel", "createdAt", "updatedAt")
+ VALUES ($1, $2, NOW(), NOW())
+ RETURNING id
+ "#,
+ permission.is_public,
+ permission
+ .public_access_level
+ .as_ref()
+ .map(ToString::to_string),
+ )
+ .fetch_one(transaction.as_mut())
+ .await?;
+
+ sqlx::query!(
+ r#"
+ INSERT INTO "ProjectPermission" ("projectId", "sharePermissionId")
+ VALUES ($1, $2)
+ "#,
+ project_id,
+ row.id,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+
+ for channel in permission.channel_share_permissions.iter().flatten() {
+ sqlx::query!(
+ r#"
+ INSERT INTO "ChannelSharePermission" (share_permission_id, channel_id, access_level)
+ VALUES ($1, $2, $3::text::"AccessLevel")
+ "#,
+ row.id,
+ channel.channel_id,
+ channel.access_level.to_string(),
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ }
+ Ok(())
+}
+
+pub(super) async fn edit_project_share_permission(
+ transaction: &mut Transaction<'_, Postgres>,
+ project_id: &str,
+ update: &UpdateSharePermissionRequestV2,
+) -> Result<(), sqlx::Error> {
+ let share_permission_id = sqlx::query_scalar!(
+ r#"SELECT "sharePermissionId" FROM "ProjectPermission" WHERE "projectId" = $1"#,
+ project_id,
+ )
+ .fetch_one(transaction.as_mut())
+ .await?;
+
+ let clear_public_level = update.is_public == Some(false);
+ let default_public_level =
+ update.is_public == Some(true) && update.public_access_level.is_none();
+ let update_public_level =
+ clear_public_level || default_public_level || update.public_access_level.is_some();
+ let public_access_level = if clear_public_level {
+ None
+ } else if default_public_level {
+ Some("view".to_owned())
+ } else {
+ update.public_access_level.as_ref().map(ToString::to_string)
+ };
+
+ sqlx::query!(
+ r#"
+ UPDATE "SharePermission"
+ SET
+ "isPublic" = CASE WHEN $2 THEN $3 ELSE "isPublic" END,
+ "publicAccessLevel" = CASE WHEN $4 THEN $5 ELSE "publicAccessLevel" END,
+ "updatedAt" = NOW()
+ WHERE id = $1
+ "#,
+ share_permission_id,
+ update.is_public.is_some(),
+ update.is_public,
+ update_public_level,
+ public_access_level,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+
+ let Some(channel_updates) = update.channel_share_permissions.as_ref() else {
+ return Ok(());
+ };
+
+ let entity_id = project_id
+ .parse()
+ .map_err(|error| sqlx::Error::Decode(Box::new(error)))?;
+ entity_access_db_utils::update_entity_access_channel_share_permissions(
+ transaction,
+ &entity_id,
+ EntityType::Project,
+ channel_updates,
+ )
+ .await?;
+
+ for channel in channel_updates {
+ match channel.operation {
+ UpdateOperation::Add => {
+ sqlx::query!(
+ r#"
+ INSERT INTO "ChannelSharePermission" (share_permission_id, channel_id, access_level)
+ VALUES ($1, $2, $3::text::"AccessLevel")
+ "#,
+ share_permission_id,
+ channel.channel_id,
+ channel.access_level.unwrap_or(AccessLevel::View).to_string(),
+ )
+ .execute(transaction.as_mut())
+ .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(transaction.as_mut())
+ .await?;
+ }
+ UpdateOperation::Replace => {
+ sqlx::query!(
+ r#"
+ UPDATE "ChannelSharePermission"
+ SET access_level = $3::text::"AccessLevel"
+ WHERE share_permission_id = $1 AND channel_id = $2
+ "#,
+ share_permission_id,
+ channel.channel_id,
+ channel
+ .access_level
+ .unwrap_or(AccessLevel::View)
+ .to_string(),
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ }
+ }
+ }
+ Ok(())
+}
diff --git a/crates/projects/src/outbound/pg_project_repo/tests.rs b/crates/projects/src/outbound/pg_project_repo/tests.rs
new file mode 100644
index 0000000000..03f7c048f7
--- /dev/null
+++ b/crates/projects/src/outbound/pg_project_repo/tests.rs
@@ -0,0 +1,544 @@
+use std::collections::HashMap;
+
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use macro_user_id::{cowlike::CowLike, user_id::MacroUserIdStr};
+use model::document::FileType;
+use model::folder::{FileSystemNode, FileSystemNodeWithIds, FolderItem};
+use model::item::Item;
+use model::project::ProjectPreviewV2;
+use models_permissions::share_permission::access_level::AccessLevel;
+use sqlx::{Pool, Postgres};
+
+use super::PgProjectRepo;
+use crate::domain::models::{CreateProjectArgs, EditProjectArgs, UploadFolderRepoArgs};
+use crate::domain::ports::ProjectRepo;
+
+const ROOT_ID: &str = "10000000-0000-0000-0000-000000000001";
+const CHILD_ID: &str = "10000000-0000-0000-0000-000000000002";
+const DELETED_ID: &str = "10000000-0000-0000-0000-000000000009";
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn history_listing_differs_from_owner_pending_listing(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool);
+
+ let viewed = repo.get_projects_for_user("macro|[email protected]").await?;
+ assert_eq!(
+ viewed
+ .iter()
+ .map(|project| project.id.as_str())
+ .collect::<Vec<_>>(),
+ vec!["10000000-0000-0000-0000-000000000005", ROOT_ID]
+ );
+
+ let owner_pending = repo
+ .get_pending_root_projects("macro|[email protected]")
+ .await?;
+ assert_eq!(owner_pending.len(), 1);
+ assert_eq!(
+ owner_pending[0].project.id,
+ "10000000-0000-0000-0000-000000000006"
+ );
+ assert_eq!(
+ owner_pending[0].upload_request_id.as_deref(),
+ Some("request-owner")
+ );
+
+ let viewer_pending = repo
+ .get_pending_root_projects("macro|[email protected]")
+ .await?;
+ assert_eq!(viewer_pending.len(), 1);
+ assert_eq!(
+ viewer_pending[0].project.id,
+ "10000000-0000-0000-0000-000000000007"
+ );
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn basic_lookup_includes_deleted_but_full_lookup_excludes_it(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool);
+
+ let basic = repo
+ .get_basic_project(DELETED_ID)
+ .await?
+ .expect("deleted project");
+ assert!(basic.deleted_at.is_some());
+ assert!(repo.get_project_by_id(DELETED_ID).await?.is_none());
+ assert!(repo.get_project_by_id(ROOT_ID).await?.is_some());
+ assert!(repo.get_basic_project("missing").await?.is_none());
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn children_are_depth_one_filtered_and_type_ordered(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool);
+ let children = repo.get_project_children(ROOT_ID).await?;
+
+ let children = children
+ .into_iter()
+ .map(|item| match item {
+ Item::Project(project) => ("project", project.id),
+ Item::Document(document) => ("document", document.document_id),
+ Item::Chat(chat) => ("chat", chat.id),
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(
+ children,
+ vec![
+ ("project", CHILD_ID.to_owned()),
+ (
+ "document",
+ "20000000-0000-0000-0000-000000000001".to_owned()
+ ),
+ ("chat", "30000000-0000-0000-0000-000000000001".to_owned()),
+ ]
+ );
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn preview_preserves_found_and_missing_input_entries(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool);
+ let missing = "10000000-0000-0000-0000-000000000099".to_owned();
+ let previews = repo
+ .batch_get_project_preview(&[CHILD_ID.to_owned(), missing.clone()])
+ .await?;
+
+ match &previews[0] {
+ ProjectPreviewV2::Found(project) => {
+ assert_eq!(project.id, CHILD_ID);
+ assert_eq!(project.path, vec!["Root", "First child"]);
+ }
+ ProjectPreviewV2::DoesNotExist(_) => panic!("child should exist"),
+ }
+ match &previews[1] {
+ ProjectPreviewV2::DoesNotExist(project) => assert_eq!(project.id, missing),
+ ProjectPreviewV2::Found(_) => panic!("missing project should not be found"),
+ }
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn reads_share_permissions_and_bumps_modified_timestamp(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool);
+ let permission = repo.get_project_share_permission(ROOT_ID).await?;
+ assert_eq!(permission.id, "share-root");
+ assert_eq!(permission.owner, "macro|[email protected]");
+ assert_eq!(permission.public_access_level, Some(AccessLevel::Edit));
+ assert_eq!(
+ permission.channel_share_permissions.expect("channel").len(),
+ 1
+ );
+
+ let before = repo
+ .get_project_by_id(ROOT_ID)
+ .await?
+ .expect("root")
+ .updated_at;
+ repo.update_project_modified(ROOT_ID).await?;
+ let after = repo
+ .get_project_by_id(ROOT_ID)
+ .await?
+ .expect("root")
+ .updated_at;
+ assert!(after > before);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn create_is_atomic_and_inserts_all_metadata(pool: Pool<Postgres>) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool.clone());
+ let permission =
+ models_permissions::share_permission::SharePermissionV2::new_project_share_permission();
+ let project = repo
+ .create_project(CreateProjectArgs {
+ user_id: "macro|[email protected]".to_owned(),
+ name: "Created".to_owned(),
+ parent_id: Some(ROOT_ID.to_owned()),
+ share_permission: permission.clone(),
+ })
+ .await?;
+
+ let metadata_count = sqlx::query_scalar!(
+ r#"
+ SELECT COUNT(*) AS "count!"
+ FROM "ProjectPermission" permission
+ JOIN "UserHistory" history ON history."itemId" = permission."projectId"
+ JOIN entity_access access ON access.entity_id::text = permission."projectId"
+ WHERE permission."projectId" = $1
+ AND history."itemType" = 'project'
+ AND access.access_level = 'owner'
+ "#,
+ project.id,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(metadata_count, 1);
+
+ assert!(
+ repo.create_project(CreateProjectArgs {
+ user_id: "macro|[email protected]".to_owned(),
+ name: "Must roll back".to_owned(),
+ parent_id: Some("missing-parent".to_owned()),
+ share_permission: permission,
+ })
+ .await
+ .is_err()
+ );
+ let rolled_back = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM "Project" WHERE name = 'Must roll back'"#
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(rolled_back, 0);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn edit_supports_parent_flags_and_sharing(pool: Pool<Postgres>) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool);
+ let unchanged = repo
+ .edit_project(EditProjectArgs {
+ project_id: CHILD_ID.to_owned(),
+ name: Some("Renamed".to_owned()),
+ update_parent: false,
+ parent_id: None,
+ share_permission: None,
+ })
+ .await?;
+ assert_eq!(unchanged.parent_id.as_deref(), Some(ROOT_ID));
+
+ let moved = repo
+ .edit_project(EditProjectArgs {
+ project_id: CHILD_ID.to_owned(),
+ name: None,
+ update_parent: true,
+ parent_id: Some("10000000-0000-0000-0000-000000000005".to_owned()),
+ share_permission: None,
+ })
+ .await?;
+ assert_eq!(
+ moved.parent_id.as_deref(),
+ Some("10000000-0000-0000-0000-000000000005")
+ );
+
+ let cleared = repo
+ .edit_project(EditProjectArgs {
+ project_id: ROOT_ID.to_owned(),
+ name: None,
+ update_parent: true,
+ parent_id: None,
+ share_permission: Some(
+ models_permissions::share_permission::UpdateSharePermissionRequestV2 {
+ is_public: Some(false),
+ public_access_level: Some(AccessLevel::Edit),
+ channel_share_permissions: None,
+ },
+ ),
+ })
+ .await?;
+ assert!(cleared.parent_id.is_none());
+ let permission = repo.get_project_share_permission(ROOT_ID).await?;
+ assert!(!permission.is_public);
+ assert_eq!(permission.public_access_level, None);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn recursive_detection_and_soft_delete_output(pool: Pool<Postgres>) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool.clone());
+ assert!(repo.is_project_recursively_nested(ROOT_ID, ROOT_ID).await?);
+ assert!(
+ repo.is_project_recursively_nested(ROOT_ID, CHILD_ID)
+ .await?
+ );
+ assert!(
+ !repo
+ .is_project_recursively_nested(CHILD_ID, "10000000-0000-0000-0000-000000000005")
+ .await?
+ );
+
+ let result = repo.soft_delete_project(ROOT_ID).await?;
+ assert_eq!(result.project_ids.len(), 3);
+ assert_eq!(result.document_ids.len(), 2);
+ assert_eq!(result.chat_ids.len(), 2);
+ let remaining_history = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM "UserHistory" WHERE "itemId" = $1"#,
+ ROOT_ID,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(remaining_history, 0);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn revert_restores_subtree_and_handles_parent_state(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool.clone());
+ sqlx::query!(
+ r#"UPDATE "Project" SET "parentId" = $2 WHERE id = $1"#,
+ ROOT_ID,
+ DELETED_ID
+ )
+ .execute(&pool)
+ .await?;
+ repo.soft_delete_project(ROOT_ID).await?;
+ let restored = repo
+ .revert_delete_project(ROOT_ID, Some(DELETED_ID.to_owned()))
+ .await?;
+ assert_eq!(restored.project_ids.len(), 4);
+ assert!(
+ repo.get_basic_project(ROOT_ID)
+ .await?
+ .expect("root")
+ .parent_id
+ .is_none()
+ );
+ assert!(repo.get_project_by_id(CHILD_ID).await?.is_some());
+
+ repo.soft_delete_project(CHILD_ID).await?;
+ repo.revert_delete_project(CHILD_ID, Some(ROOT_ID.to_owned()))
+ .await?;
+ assert_eq!(
+ repo.get_basic_project(CHILD_ID)
+ .await?
+ .expect("child")
+ .parent_id
+ .as_deref(),
+ Some(ROOT_ID)
+ );
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn purge_returns_outputs_and_removes_access_and_permissions(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool.clone());
+ let deleted = repo.soft_delete_project(ROOT_ID).await?;
+ let document_id = &deleted.document_ids[0];
+ let bom_id = sqlx::query_scalar!(
+ r#"INSERT INTO "DocumentBom" ("documentId") VALUES ($1) RETURNING id"#,
+ document_id,
+ )
+ .fetch_one(&pool)
+ .await?;
+ sqlx::query!(
+ r#"
+ INSERT INTO "BomPart" (sha, path, "documentBomId")
+ VALUES ('shared-sha', 'one', $1), ('shared-sha', 'two', $1), ('other-sha', 'three', $1)
+ "#,
+ bom_id,
+ )
+ .execute(&pool)
+ .await?;
+
+ let result = repo.purge_deleted_project_tree(ROOT_ID).await?;
+ assert_eq!(result.project_ids.len(), 4);
+ assert_eq!(result.documents.len(), 2);
+ assert_eq!(result.chat_ids.len(), 2);
+ assert_eq!(
+ result.bom_shas,
+ vec![("other-sha".to_owned(), 1), ("shared-sha".to_owned(), 2)]
+ );
+
+ let purged_ids = result
+ .project_ids
+ .iter()
+ .chain(result.documents.iter().map(|(id, _)| id))
+ .chain(&result.chat_ids)
+ .cloned()
+ .collect::<Vec<_>>();
+ let remaining_access = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM entity_access WHERE entity_id::text = ANY($1)"#,
+ &purged_ids,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(remaining_access, 0);
+ let remaining_permissions = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM "ProjectPermission" WHERE "projectId" = ANY($1)"#,
+ &result.project_ids,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(remaining_permissions, 0);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn purge_rolls_back_all_deletions(pool: Pool<Postgres>) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool.clone());
+ repo.soft_delete_project(ROOT_ID).await?;
+
+ let mut transaction = pool.begin().await?;
+ let result = super::delete::purge_deleted_project_tree(&mut transaction, ROOT_ID).await?;
+ assert!(!result.project_ids.is_empty());
+ transaction.rollback().await?;
+
+ assert!(repo.get_basic_project(ROOT_ID).await?.is_some());
+ let access_count = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM entity_access WHERE entity_id::text = $1"#,
+ ROOT_ID,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(access_count, 2);
+ let permission_count = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM "ProjectPermission" WHERE "projectId" = $1"#,
+ ROOT_ID,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(permission_count, 1);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn upload_folder_preserves_tree_metadata_and_compensates(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool.clone());
+ let file = FolderItem {
+ name: "nested.pdf".to_owned(),
+ full_name: "nested.pdf".to_owned(),
+ file_type: Some(FileType::Pdf),
+ relative_path: "/Upload/Nested".to_owned(),
+ sha: "upload-sha".to_owned(),
+ };
+ let root_folder = FileSystemNode::Folder(HashMap::from([
+ (
+ "Nested".to_owned(),
+ FileSystemNode::Folder(HashMap::from([(
+ "nested.pdf".to_owned(),
+ FileSystemNode::File(file),
+ )])),
+ ),
+ ("Empty".to_owned(), FileSystemNode::Folder(HashMap::new())),
+ ]));
+ let result = repo
+ .upload_folder(UploadFolderRepoArgs {
+ user_id: MacroUserIdStr::parse_from_str("macro|[email protected]")?.into_owned(),
+ share_permission:
+ models_permissions::share_permission::SharePermissionV2::new_project_share_permission(),
+ root_folder,
+ root_folder_name: "Upload".to_owned(),
+ upload_request_id: "lambda-request-id".to_owned(),
+ parent_id: Some(ROOT_ID.to_owned()),
+ })
+ .await?;
+
+ assert_eq!(result.project_ids.len(), 3);
+ assert_eq!(result.documents.len(), 1);
+ let FileSystemNodeWithIds::Folder { project_id, .. } = &result.file_system else {
+ panic!("root must be a folder");
+ };
+ let root = sqlx::query!(
+ r#"
+ SELECT "parentId" AS parent_id, "uploadPending" AS upload_pending,
+ "uploadRequestId" AS upload_request_id
+ FROM "Project" WHERE id = $1
+ "#,
+ project_id,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(root.parent_id.as_deref(), Some(ROOT_ID));
+ assert!(root.upload_pending);
+ assert_eq!(root.upload_request_id.as_deref(), Some("lambda-request-id"));
+ assert_eq!(result.documents[0].project_name.as_deref(), Some("Nested"));
+
+ let document_ids = result
+ .documents
+ .iter()
+ .map(|document| document.document_id.clone())
+ .collect::<Vec<_>>();
+ repo.delete_uploaded_tree(&result.project_ids, &document_ids)
+ .await?;
+ let remaining = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM "Project" WHERE id = ANY($1)"#,
+ &result.project_ids,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(remaining, 0);
+ let remaining_access = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM entity_access WHERE entity_id::text = ANY($1)"#,
+ &document_ids,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(remaining_access, 0);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("projects_test_data"))
+)]
+async fn mark_uploaded_is_recursive_and_rejects_missing_root(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let repo = PgProjectRepo::new(pool.clone());
+ let project_ids = repo
+ .mark_projects_uploaded("10000000-0000-0000-0000-000000000006")
+ .await?;
+ assert_eq!(project_ids.len(), 2);
+ let pending = sqlx::query_scalar!(
+ r#"SELECT COUNT(*) AS "count!" FROM "Project" WHERE id = ANY($1) AND "uploadPending""#,
+ &project_ids,
+ )
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(pending, 0);
+ assert!(repo.mark_projects_uploaded("missing").await.is_err());
+ Ok(())
+}
diff --git a/crates/projects/src/outbound/pg_project_repo/upload_folder.rs b/crates/projects/src/outbound/pg_project_repo/upload_folder.rs
new file mode 100644
index 0000000000..23c41a3c77
--- /dev/null
+++ b/crates/projects/src/outbound/pg_project_repo/upload_folder.rs
@@ -0,0 +1,365 @@
+use std::collections::HashMap;
+
+use async_recursion::async_recursion;
+use entity_access_db_utils::{
+ AccessLevel, EntityAccessSourceType, EntityType, insert_entity_access_row,
+};
+use macro_user_id::user_id::MacroUserIdStr;
+use model::document::{DocumentMetadata, FileType, FileTypeExt};
+use model::folder::{FileSystemNode, FileSystemNodeWithIds, UploadFolderWithIdsResponse};
+use model::project::Project;
+use models_permissions::share_permission::SharePermissionV2;
+use sqlx::{Postgres, Transaction};
+
+use crate::domain::models::UploadFolderRepoArgs;
+
+use super::share;
+
+pub(super) async fn upload_folder(
+ transaction: &mut Transaction<'_, Postgres>,
+ args: UploadFolderRepoArgs,
+) -> Result<UploadFolderWithIdsResponse, sqlx::Error> {
+ let root_project = create_pending_project(
+ transaction,
+ args.user_id.clone(),
+ &args.share_permission,
+ &args.root_folder_name,
+ args.parent_id.as_deref(),
+ &args.upload_request_id,
+ )
+ .await?;
+
+ let FileSystemNode::Folder(root_content) = &args.root_folder else {
+ return Err(sqlx::Error::Protocol(
+ "expected a folder node, found a file".to_owned(),
+ ));
+ };
+
+ let mut project_ids = vec![root_project.id.clone()];
+ let mut documents = Vec::new();
+ let mut extended_content = HashMap::new();
+ for (name, node) in root_content {
+ let extended_node = traverse_with_ids(
+ transaction,
+ node,
+ args.user_id.clone(),
+ &args.share_permission,
+ name,
+ &root_project,
+ &args.upload_request_id,
+ &mut project_ids,
+ &mut documents,
+ )
+ .await?;
+ extended_content.insert(name.clone(), extended_node);
+ }
+
+ insert_tree_history(transaction, args.user_id.as_ref(), &project_ids, &documents).await?;
+
+ Ok(UploadFolderWithIdsResponse {
+ file_system: FileSystemNodeWithIds::Folder {
+ content: extended_content,
+ project_id: root_project.id,
+ },
+ project_ids,
+ documents,
+ })
+}
+
+#[async_recursion]
+#[expect(clippy::too_many_arguments, reason = "recursive tree traversal state")]
+async fn traverse_with_ids(
+ transaction: &mut Transaction<'_, Postgres>,
+ node: &FileSystemNode,
+ user_id: MacroUserIdStr<'static>,
+ share_permission: &SharePermissionV2,
+ name: &str,
+ parent_project: &Project,
+ upload_request_id: &str,
+ project_ids: &mut Vec<String>,
+ documents: &mut Vec<DocumentMetadata>,
+) -> Result<FileSystemNodeWithIds, sqlx::Error> {
+ match node {
+ FileSystemNode::File(item) => {
+ let document =
+ create_empty_document(transaction, user_id, share_permission, item, parent_project)
+ .await?;
+ let document_id = document.document_id.clone();
+ documents.push(document);
+ Ok(FileSystemNodeWithIds::File {
+ item: item.clone(),
+ document_id,
+ })
+ }
+ FileSystemNode::Folder(content) => {
+ let project = create_pending_project(
+ transaction,
+ user_id.clone(),
+ share_permission,
+ name,
+ Some(&parent_project.id),
+ upload_request_id,
+ )
+ .await?;
+ project_ids.push(project.id.clone());
+
+ let mut extended_content = HashMap::new();
+ for (child_name, child) in content {
+ let extended_node = traverse_with_ids(
+ transaction,
+ child,
+ user_id.clone(),
+ share_permission,
+ child_name,
+ &project,
+ upload_request_id,
+ project_ids,
+ documents,
+ )
+ .await?;
+ extended_content.insert(child_name.clone(), extended_node);
+ }
+ Ok(FileSystemNodeWithIds::Folder {
+ content: extended_content,
+ project_id: project.id,
+ })
+ }
+ }
+}
+
+async fn create_pending_project(
+ transaction: &mut Transaction<'_, Postgres>,
+ user_id: MacroUserIdStr<'static>,
+ share_permission: &SharePermissionV2,
+ name: &str,
+ parent_id: Option<&str>,
+ upload_request_id: &str,
+) -> Result<Project, sqlx::Error> {
+ let project = sqlx::query_as!(
+ Project,
+ r#"
+ INSERT INTO "Project"
+ (name, "userId", "parentId", "createdAt", "updatedAt", "uploadPending", "uploadRequestId")
+ VALUES ($1, $2, $3, NOW(), NOW(), true, $4)
+ RETURNING
+ id,
+ name,
+ "userId" AS user_id,
+ "parentId" AS parent_id,
+ "createdAt"::timestamptz AS created_at,
+ "updatedAt"::timestamptz AS updated_at,
+ "deletedAt"::timestamptz AS deleted_at
+ "#,
+ name,
+ user_id.as_ref(),
+ parent_id,
+ upload_request_id,
+ )
+ .fetch_one(transaction.as_mut())
+ .await?;
+
+ share::create_project_share_permission(transaction, &project.id, share_permission).await?;
+ let entity_id = project
+ .id
+ .parse()
+ .map_err(|error| sqlx::Error::Decode(Box::new(error)))?;
+ insert_entity_access_row(
+ transaction,
+ &entity_id,
+ EntityType::Project,
+ user_id.as_ref(),
+ EntityAccessSourceType::User,
+ AccessLevel::Owner,
+ )
+ .await?;
+ Ok(project)
+}
+
+async fn create_empty_document(
+ transaction: &mut Transaction<'_, Postgres>,
+ user_id: MacroUserIdStr<'static>,
+ share_permission: &SharePermissionV2,
+ item: &model::folder::FolderItem,
+ project: &Project,
+) -> Result<DocumentMetadata, sqlx::Error> {
+ let document_name =
+ FileType::clean_document_name(&item.name).unwrap_or_else(|| item.name.clone());
+ let document = sqlx::query!(
+ r#"
+ INSERT INTO "Document" (owner, name, "fileType", "projectId", "createdAt", "updatedAt")
+ VALUES ($1, $2, $3, $4, NOW(), NOW())
+ RETURNING id, "createdAt"::timestamptz AS created_at, "updatedAt"::timestamptz AS updated_at
+ "#,
+ user_id.as_ref(),
+ document_name,
+ item.file_type
+ .map(|file_type| file_type.as_str().to_owned()),
+ project.id,
+ )
+ .fetch_one(transaction.as_mut())
+ .await?;
+
+ let (version_id, created_at, updated_at) = if item.file_type == Some(FileType::Docx) {
+ let version = sqlx::query!(
+ r#"
+ INSERT INTO "DocumentBom" ("documentId", "createdAt", "updatedAt")
+ VALUES ($1, NOW(), NOW())
+ RETURNING id, "createdAt"::timestamptz AS created_at, "updatedAt"::timestamptz AS updated_at
+ "#,
+ document.id,
+ )
+ .fetch_one(transaction.as_mut())
+ .await?;
+ (version.id, version.created_at, version.updated_at)
+ } else {
+ let version = sqlx::query!(
+ r#"
+ INSERT INTO "DocumentInstance" ("documentId", sha, "createdAt", "updatedAt")
+ VALUES ($1, $2, NOW(), NOW())
+ RETURNING id, "createdAt"::timestamptz AS created_at, "updatedAt"::timestamptz AS updated_at
+ "#,
+ document.id,
+ item.sha,
+ )
+ .fetch_one(transaction.as_mut())
+ .await?;
+ (version.id, version.created_at, version.updated_at)
+ };
+
+ create_document_share_permission(transaction, &document.id, share_permission).await?;
+ let entity_id = document
+ .id
+ .parse()
+ .map_err(|error| sqlx::Error::Decode(Box::new(error)))?;
+ insert_entity_access_row(
+ transaction,
+ &entity_id,
+ EntityType::Document,
+ user_id.as_ref(),
+ EntityAccessSourceType::User,
+ AccessLevel::Owner,
+ )
+ .await?;
+
+ Ok(DocumentMetadata::new_document(
+ &document.id,
+ version_id,
+ user_id,
+ &document_name,
+ item.file_type,
+ &item.sha,
+ None,
+ None,
+ None,
+ Some(&project.id),
+ Some(&project.name),
+ created_at,
+ updated_at,
+ None,
+ ))
+}
+
+async fn create_document_share_permission(
+ transaction: &mut Transaction<'_, Postgres>,
+ document_id: &str,
+ permission: &SharePermissionV2,
+) -> Result<(), sqlx::Error> {
+ let permission_id = sqlx::query_scalar!(
+ r#"
+ INSERT INTO "SharePermission" ("isPublic", "publicAccessLevel", "createdAt", "updatedAt")
+ VALUES ($1, $2, NOW(), NOW())
+ RETURNING id
+ "#,
+ permission.is_public,
+ permission
+ .public_access_level
+ .as_ref()
+ .map(ToString::to_string),
+ )
+ .fetch_one(transaction.as_mut())
+ .await?;
+ sqlx::query!(
+ r#"INSERT INTO "DocumentPermission" ("documentId", "sharePermissionId") VALUES ($1, $2)"#,
+ document_id,
+ permission_id,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ for channel in permission.channel_share_permissions.iter().flatten() {
+ sqlx::query!(
+ r#"
+ INSERT INTO "ChannelSharePermission" (share_permission_id, channel_id, access_level)
+ VALUES ($1, $2, $3::text::"AccessLevel")
+ "#,
+ permission_id,
+ channel.channel_id,
+ channel.access_level.to_string(),
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ }
+ Ok(())
+}
+
+async fn insert_tree_history(
+ transaction: &mut Transaction<'_, Postgres>,
+ user_id: &str,
+ project_ids: &[String],
+ documents: &[DocumentMetadata],
+) -> Result<(), sqlx::Error> {
+ let document_ids = documents
+ .iter()
+ .map(|document| document.document_id.clone())
+ .collect::<Vec<_>>();
+ sqlx::query!(
+ r#"
+ INSERT INTO "UserHistory" ("userId", "itemId", "itemType", "createdAt", "updatedAt")
+ SELECT $1, id, 'project', NOW(), NOW() FROM UNNEST($2::text[]) AS id
+ ON CONFLICT ("userId", "itemId", "itemType") DO UPDATE SET "updatedAt" = NOW()
+ "#,
+ user_id,
+ project_ids,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ sqlx::query!(
+ r#"
+ INSERT INTO "UserHistory" ("userId", "itemId", "itemType", "createdAt", "updatedAt")
+ SELECT $1, id, 'document', NOW(), NOW() FROM UNNEST($2::text[]) AS id
+ ON CONFLICT ("userId", "itemId", "itemType") DO UPDATE SET "updatedAt" = NOW()
+ "#,
+ user_id,
+ &document_ids,
+ )
+ .execute(transaction.as_mut())
+ .await?;
+ Ok(())
+}
+
+pub(super) async fn mark_projects_uploaded(
+ transaction: &mut Transaction<'_, Postgres>,
+ root_project_id: &str,
+) -> Result<Vec<String>, sqlx::Error> {
+ let project_ids = sqlx::query_scalar!(
+ r#"
+ WITH RECURSIVE project_hierarchy AS (
+ SELECT id FROM "Project" WHERE id = $1
+ UNION ALL
+ SELECT child.id
+ FROM "Project" child
+ JOIN project_hierarchy parent ON child."parentId" = parent.id
+ )
+ UPDATE "Project"
+ SET "uploadPending" = false
+ WHERE id IN (SELECT id FROM project_hierarchy)
+ RETURNING id
+ "#,
+ root_project_id,
+ )
+ .fetch_all(transaction.as_mut())
+ .await?;
+ if project_ids.is_empty() {
+ return Err(sqlx::Error::RowNotFound);
+ }
+ Ok(project_ids)
+}
diff --git a/crates/projects/src/outbound/s3_upload_urls.rs b/crates/projects/src/outbound/s3_upload_urls.rs
new file mode 100644
index 0000000000..b0420b23b9
--- /dev/null
+++ b/crates/projects/src/outbound/s3_upload_urls.rs
@@ -0,0 +1,122 @@
+//! S3 adapter for project upload destinations.
+
+use std::time::Duration;
+
+use anyhow::Context;
+use aws_sdk_s3::presigning::PresigningConfig;
+use base64::Engine;
+use model::document::{ContentType, FileType};
+use s3_key::BulkUploadStagingKey;
+
+use crate::domain::ports::ProjectUploadUrlPort;
+
+/// S3-backed adapter for project upload URLs and bucket destinations.
+#[derive(Clone, Debug)]
+pub struct S3ProjectUploadAdapter {
+ client: aws_sdk_s3::Client,
+ document_storage_bucket: String,
+ docx_upload_bucket: String,
+ upload_zip_staging_bucket: String,
+}
+
+impl S3ProjectUploadAdapter {
+ /// Create an upload adapter with the document, DOCX staging, and ZIP staging buckets.
+ pub fn new(
+ client: aws_sdk_s3::Client,
+ document_storage_bucket: impl Into<String>,
+ docx_upload_bucket: impl Into<String>,
+ upload_zip_staging_bucket: impl Into<String>,
+ ) -> Self {
+ Self {
+ client,
+ document_storage_bucket: document_storage_bucket.into(),
+ docx_upload_bucket: docx_upload_bucket.into(),
+ upload_zip_staging_bucket: upload_zip_staging_bucket.into(),
+ }
+ }
+}
+
+impl ProjectUploadUrlPort for S3ProjectUploadAdapter {
+ #[tracing::instrument(skip(self), err)]
+ async fn put_upload_zip_staging_presigned_url(
+ &self,
+ key: BulkUploadStagingKey,
+ sha: String,
+ ) -> anyhow::Result<String> {
+ put_presigned_url(
+ &self.client,
+ &self.upload_zip_staging_bucket,
+ &key.to_key(),
+ &sha,
+ FileType::Zip.into(),
+ )
+ .await
+ }
+
+ #[tracing::instrument(skip(self), err)]
+ async fn put_document_storage_presigned_url(
+ &self,
+ key: String,
+ sha: String,
+ content_type: ContentType,
+ ) -> anyhow::Result<String> {
+ put_presigned_url(
+ &self.client,
+ &self.document_storage_bucket,
+ &key,
+ &sha,
+ content_type,
+ )
+ .await
+ }
+
+ #[tracing::instrument(skip(self), err)]
+ async fn put_docx_upload_presigned_url(
+ &self,
+ key: String,
+ sha: String,
+ content_type: ContentType,
+ ) -> anyhow::Result<String> {
+ put_presigned_url(
+ &self.client,
+ &self.docx_upload_bucket,
+ &key,
+ &sha,
+ content_type,
+ )
+ .await
+ }
+
+ fn document_storage_bucket(&self) -> &str {
+ &self.document_storage_bucket
+ }
+
+ fn docx_upload_bucket(&self) -> &str {
+ &self.docx_upload_bucket
+ }
+}
+
+async fn put_presigned_url(
+ client: &aws_sdk_s3::Client,
+ bucket: &str,
+ key: &str,
+ sha: &str,
+ content_type: ContentType,
+) -> anyhow::Result<String> {
+ let expiry_duration = Duration::from_secs(2 * 60);
+ let payload_sha256_bytes = hex::decode(sha).context("able to decode hex sha")?;
+ let base64_encoded_sha = base64::engine::general_purpose::STANDARD.encode(payload_sha256_bytes);
+
+ tracing::trace!("sha info {sha} {base64_encoded_sha}");
+
+ let presigned_url = client
+ .put_object()
+ .bucket(bucket)
+ .key(key)
+ .content_type(content_type.mime_type())
+ .checksum_sha256(base64_encoded_sha)
+ .presigned(PresigningConfig::expires_in(expiry_duration)?)
+ .await?;
+
+ Ok(macro_aws_config::transform_aws_url(presigned_url.uri()))
+}
diff --git a/crates/projects/src/outbound/sha_counter.rs b/crates/projects/src/outbound/sha_counter.rs
new file mode 100644
index 0000000000..e041048c66
--- /dev/null
+++ b/crates/projects/src/outbound/sha_counter.rs
@@ -0,0 +1,23 @@
+//! Redis adapter for content-hash reference counts.
+
+use crate::domain::ports::ShaCounterPort;
+
+/// Redis-backed content-hash counter adapter.
+#[derive(Clone)]
+pub struct ShaCountAdapter {
+ redis: macro_sha_count_client::Redis,
+}
+
+impl ShaCountAdapter {
+ /// Create a SHA counter adapter from the shared Redis client.
+ pub fn new(redis: macro_sha_count_client::Redis) -> Self {
+ Self { redis }
+ }
+}
+
+impl ShaCounterPort for ShaCountAdapter {
+ #[tracing::instrument(skip(self), err)]
+ async fn decrement_counts(&self, sha_counts: &[(String, i64)]) -> anyhow::Result<()> {
+ self.redis.decrement_counts(&sha_counts.to_vec()).await
+ }
+}
diff --git a/crates/projects/src/outbound/sqs_search_indexer.rs b/crates/projects/src/outbound/sqs_search_indexer.rs
new file mode 100644
index 0000000000..eb89ae672f
--- /dev/null
+++ b/crates/projects/src/outbound/sqs_search_indexer.rs
@@ -0,0 +1,101 @@
+//! SQS adapter for project search indexing and document deletion.
+
+use std::sync::Arc;
+
+use sqs_client::search::{
+ SearchQueueMessage,
+ chat::RemoveChatMessage,
+ document::DocumentId,
+ project::{RemoveProject, UpsertProject},
+};
+
+use crate::domain::ports::ProjectSearchIndexer;
+
+/// SQS-backed project search-index and document-deletion adapter.
+#[derive(Clone)]
+pub struct SqsProjectSearchIndexer {
+ sqs: Arc<sqs_client::SQS>,
+}
+
+impl SqsProjectSearchIndexer {
+ /// Create a project search indexer from the shared SQS client.
+ pub fn new(sqs: Arc<sqs_client::SQS>) -> Self {
+ Self { sqs }
+ }
+}
+
+impl ProjectSearchIndexer for SqsProjectSearchIndexer {
+ #[tracing::instrument(skip(self), err)]
+ async fn upsert_projects(&self, project_ids: Vec<String>) -> anyhow::Result<()> {
+ let messages = project_ids
+ .into_iter()
+ .map(|project_id| {
+ SearchQueueMessage::UpsertProject(UpsertProject {
+ project_id,
+ index_override: None,
+ })
+ })
+ .collect();
+
+ self.sqs
+ .bulk_send_message_to_search_event_queue(messages)
+ .await
+ }
+
+ #[tracing::instrument(skip(self), err)]
+ async fn remove_projects(&self, project_ids: Vec<String>) -> anyhow::Result<()> {
+ let messages = project_ids
+ .into_iter()
+ .map(|project_id| {
+ SearchQueueMessage::RemoveProject(RemoveProject {
+ project_id,
+ index_override: None,
+ })
+ })
+ .collect();
+
+ self.sqs
+ .bulk_send_message_to_search_event_queue(messages)
+ .await
+ }
+
+ #[tracing::instrument(skip(self), err)]
+ async fn remove_chats(&self, chat_ids: Vec<String>) -> anyhow::Result<()> {
+ let messages = chat_ids
+ .into_iter()
+ .map(|chat_id| {
+ SearchQueueMessage::RemoveChatMessage(RemoveChatMessage {
+ chat_id,
+ message_id: None,
+ index_override: None,
+ })
+ })
+ .collect();
+
+ self.sqs
+ .bulk_send_message_to_search_event_queue(messages)
+ .await
+ }
+
+ #[tracing::instrument(skip(self), err)]
+ async fn remove_documents(&self, document_ids: Vec<String>) -> anyhow::Result<()> {
+ let messages = document_ids
+ .into_iter()
+ .map(|document_id| SearchQueueMessage::RemoveDocument(DocumentId { document_id }))
+ .collect();
+
+ self.sqs
+ .bulk_send_message_to_search_event_queue(messages)
+ .await
+ }
+
+ #[tracing::instrument(skip(self), err)]
+ async fn enqueue_document_deletes(
+ &self,
+ documents: Vec<(String, String)>,
+ ) -> anyhow::Result<()> {
+ self.sqs
+ .bulk_enqueue_document_delete_with_owner(documents)
+ .await
+ }
+}
diff --git a/services/document_storage_service/Cargo.toml b/services/document_storage_service/Cargo.toml
index f2fa30990b..3eaa03a403 100644
--- a/services/document_storage_service/Cargo.toml
+++ b/services/document_storage_service/Cargo.toml
@@ -120,7 +120,6 @@ macro_middleware = { path = "../../crates/macro_middleware", default-features =
"cloud_storage",
"user_permissions",
] }
-macro_project_utils = { path = "../../crates/macro_project_utils" }
macro_queues = { path = "../../crates/macro_queues" }
macro_service_urls = { path = "../../crates/macro_service_urls" }
macro_sha_count_client = { path = "../../crates/macro_sha_count_client" }
@@ -146,6 +145,7 @@ notification = { path = "../../crates/notification" }
opensearch_client = { path = "../../crates/opensearch_client" }
properties = { path = "../../crates/properties" }
properties_service = { path = "../../crates/properties_service" }
+projects_hex = { path = "../../crates/projects", package = "projects" }
rate_limit = { path = "../../crates/rate_limit", default-features = false, features = [
"axum",
] }
diff --git a/services/document_storage_service/src/api/context.rs b/services/document_storage_service/src/api/context.rs
index d29dd17e5f..360669f346 100644
--- a/services/document_storage_service/src/api/context.rs
+++ b/services/document_storage_service/src/api/context.rs
@@ -77,6 +77,14 @@ use macro_sha_count_client::Redis;
use notification::domain::service::SqsNotificationIngress;
use notification::outbound::queue::SqsQueue;
use opensearch_client::OpensearchClient;
+use projects_hex::{
+ domain::service::ProjectServiceImpl,
+ inbound::axum_router::ProjectRouterState,
+ outbound::{
+ DynamoBulkUploadAdapter, PgProjectRepo, S3ProjectUploadAdapter, ShaCountAdapter,
+ SqsProjectSearchIndexer,
+ },
+};
use properties::{
NotificationServiceImpl, PermissionServiceImpl, PropertiesPgRepo, PropertiesServiceImpl,
};
@@ -103,11 +111,6 @@ use webhook::{
},
};
-#[derive(Debug, Clone)]
-pub struct InternalFlag {
- pub internal: bool,
-}
-
/// CRM service for DSS — no-op resolver since DSS doesn't populate.
pub(crate) type DssCrmService = crm::domain::service::CrmServiceImpl<
crm::outbound::companies_repo::CompaniesRepositoryImpl,
@@ -252,6 +255,20 @@ pub(crate) type AuthorizationService = MacroAuthorizationServiceImpl<MacroAuthJw
pub(crate) type DocumentsState =
DocumentRouterState<DocumentService, EntityAccessService, AuthorizationService>;
+/// Concrete project service wired into DSS.
+pub(crate) type ProjectService = ProjectServiceImpl<
+ PgProjectRepo,
+ S3ProjectUploadAdapter,
+ DynamoBulkUploadAdapter,
+ ShaCountAdapter,
+ EntityAccessManagementService,
+ SqsProjectSearchIndexer,
+>;
+
+/// Type alias for the projects router state.
+pub(crate) type ProjectsState =
+ ProjectRouterState<ProjectService, EntityAccessService, AuthorizationService>;
+
/// Type alias for the legacy channel list service.
pub(crate) type DssChannelListService =
ChannelListServiceImpl<PgChannelsRepo, PgChannelsRepo, FrecencyPgStorage>;
@@ -399,6 +416,7 @@ pub(crate) struct ApiContext {
pub channel_list_state: DssChannelListState,
pub entity_access_service: Arc<EntityAccessService>,
pub documents_state: DocumentsState,
+ pub projects_state: ProjectsState,
pub channels_state: DssChannelsState,
pub bots_state: DssBotsState,
pub channel_bot_webhook_state: DssChannelBotWebhookState,
diff --git a/services/document_storage_service/src/api/internal/mod.rs b/services/document_storage_service/src/api/internal/mod.rs
index 5fc7e06005..6df8980980 100644
--- a/services/document_storage_service/src/api/internal/mod.rs
+++ b/services/document_storage_service/src/api/internal/mod.rs
@@ -1,8 +1,7 @@
use super::{
- context::{ApiContext, AuthorizationService, EntityAccessService},
+ context::ApiContext,
documents::{export_document, get_document_version},
history::upsert_history,
- projects::upload_folder,
};
use super::{documents::get_document_access_level, user::delete_user_items};
use super::{documents::save_document, history::delete_history};
@@ -14,7 +13,9 @@ use super::{
},
user::populate_items,
};
-use crate::api::context::DocumentService;
+use crate::api::context::{
+ AuthorizationService, DocumentService, EntityAccessService, ProjectService,
+};
use crate::api::items::get_item_ids;
use crate::api::threads::get_thread_access_level;
use crate::api::{documents::get_documents_metadata, items::validate_item_ids};
@@ -158,11 +159,23 @@ pub fn router(state: ApiContext) -> Router<ApiContext> {
// Project routes
.route(
"/projects/upload",
- post(upload_folder::upload_folder_handler),
+ post(
+ projects_hex::inbound::axum_router::upload_folder::upload_folder_handler::<
+ ProjectService,
+ EntityAccessService,
+ AuthorizationService,
+ >,
+ ),
)
.route(
"/projects/mark_uploaded",
- post(upload_folder::mark_uploaded_handler),
+ post(
+ projects_hex::inbound::axum_router::upload_folder::mark_uploaded_handler::<
+ ProjectService,
+ EntityAccessService,
+ AuthorizationService,
+ >,
+ ),
)
.route("/item_ids", get(get_item_ids::get_item_ids_handler))
.route("/validate_item_ids", post(validate_item_ids::handler))
diff --git a/services/document_storage_service/src/api/mod.rs b/services/document_storage_service/src/api/mod.rs
index dc8adda9e3..992b151054 100644
--- a/services/document_storage_service/src/api/mod.rs
+++ b/services/document_storage_service/src/api/mod.rs
@@ -37,7 +37,6 @@ mod instructions;
mod internal;
mod notification;
mod pins;
-mod projects;
mod recents;
mod user;
mod user_document_view_location;
@@ -163,23 +162,24 @@ fn api_router(state: ApiContext) -> Router {
)
.nest(
"/projects",
- projects::router(state.clone()).layer(ServiceBuilder::new().layer(
- axum::middleware::from_fn(|req: Request, next: Next| async move {
- match req.method() {
- &Method::PUT | &Method::POST | &Method::PATCH | &Method::DELETE => {
- let uri = req.uri().to_string();
- // We do not want the upload a folder in the background
- // If a user cancels the call we need to make sure we aren't
- // creating documents/projects
- if !uri.contains("/upload") {
- return next.run(req).await;
+ projects_hex::inbound::axum_router::projects_router(state.projects_state.clone())
+ .layer(ServiceBuilder::new().layer(axum::middleware::from_fn(
+ |req: Request, next: Next| async move {
+ match req.method() {
+ &Method::PUT | &Method::POST | &Method::PATCH | &Method::DELETE => {
+ let uri = req.uri().to_string();
+ // We do not want the upload a folder in the background
+ // If a user cancels the call we need to make sure we aren't
+ // creating documents/projects
+ if !uri.contains("/upload") {
+ return next.run(req).await;
+ }
+ tokio::task::spawn(next.run(req)).await.unwrap()
}
- tokio::task::spawn(next.run(req)).await.unwrap()
+ _ => next.run(req).await,
}
- _ => next.run(req).await,
- }
- }),
- )),
+ },
+ ))),
)
.nest(
"/annotations",
diff --git a/services/document_storage_service/src/api/projects/create_project.rs b/services/document_storage_service/src/api/projects/create_project.rs
deleted file mode 100644
index b1f4ea4cba..0000000000
--- a/services/document_storage_service/src/api/projects/create_project.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-use crate::api::context::ApiContext;
-use crate::api::context::{AuthorizationService, EntityAccessService};
-use axum::{
- extract::State,
- http::StatusCode,
- response::{IntoResponse, Json, Response},
-};
-use entity_access::inbound::axum_extractors::ProjectBodyAccessLevelExtractor;
-use entity_access_management::domain::ports::EntityAccessManagementService;
-use macro_authorization::MacroAuthorizationExtractor;
-use model::{
- project::{Project, request::CreateProjectRequest, response::CreateProjectResponse},
- response::{GenericErrorResponse, GenericResponse},
-};
-use model_entity::EntityType;
-use models_permissions::share_permission::SharePermissionV2;
-use models_permissions::share_permission::access_level::EditAccessLevel;
-use sqs_client::search::{SearchQueueMessage, project::UpsertProject};
-use unicode_segmentation::UnicodeSegmentation;
-
-/// Creates a new project.
-/// The project can be created as a sub-project of another project or as a top-level project.
-#[utoipa::path(
- tag = "project",
- post,
- path = "/projects",
- request_body = CreateProjectRequest,
- responses(
- (status = 200, body=CreateProjectResponse),
- (status = 401, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user_context, project), fields(user_id=?user_context.macro_user_id))]
-pub async fn create_project_handler(
- State(ctx): State<ApiContext>,
- user_context: MacroAuthorizationExtractor<AuthorizationService>,
- project: ProjectBodyAccessLevelExtractor<
- EditAccessLevel,
- CreateProjectRequest,
- EntityAccessService,
- >,
-) -> Result<Response, Response> {
- let req = project.into_inner();
-
- let project =
- create_project_v2(ctx, user_context, req)
- .await
- .map_err(|(status_code, message)| {
- tracing::error!(error=?message, "unable to create project");
- (
- status_code,
- Json(GenericErrorResponse {
- error: true,
- message,
- }),
- )
- .into_response()
- })?;
-
- Ok(GenericResponse::builder()
- .data(&project)
- .send(StatusCode::OK))
-}
-
-async fn create_project_v2(
- ctx: ApiContext,
- user_context: MacroAuthorizationExtractor<AuthorizationService>,
- req: CreateProjectRequest,
-) -> Result<Project, (StatusCode, String)> {
- if req.name.graphemes(true).count() > 100 {
- return Err((StatusCode::BAD_REQUEST, "name too long".to_string()));
- }
-
- let share_permission = SharePermissionV2::new_project_share_permission();
-
- let project = match macro_db_client::projects::create_project_v2(
- ctx.db.clone(),
- user_context.macro_user_id.clone(),
- &req.name,
- req.project_parent_id.map(|p| p.to_string()),
- &share_permission,
- )
- .await
- {
- Ok(project) => project,
- Err(e) => {
- tracing::error!(error=?e, "unable to create project");
- return Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string()));
- }
- };
-
- tokio::spawn({
- let sqs_client = ctx.sqs_client.clone();
- let project_id = project.id.clone();
- async move {
- let _ = sqs_client
- .send_message_to_search_event_queue(SearchQueueMessage::UpsertProject(
- UpsertProject {
- project_id: project_id.clone(),
- index_override: None,
- },
- ))
- .await
- .inspect_err(
- |e| tracing::error!(error=?e, project_id=?project_id, "unable to enqueue project search upsert"),
- );
- }
- });
-
- // update project modified if necessary
- if let Some(project_id) = req.project_parent_id {
- tracing::trace!("updating project modified date");
- // SAFETY: this is a uuid.
- let entity_id = macro_uuid::string_to_uuid(&project.id).unwrap();
-
- let _ = ctx
- .entity_access_management_service
- .add_entity_to_project(&entity_id, EntityType::Project, &project_id)
- .await
- .inspect_err(
- |e| tracing::error!(error=?e, entity_id=?entity_id, project_id=?project_id, "unable to update entity access for project"),
- );
-
- macro_project_utils::update_project_modified(
- &ctx.db,
- Some(ctx.sqs_client.as_ref()),
- macro_project_utils::ProjectModifiedArgs {
- project_id: Some(project_id.to_string()),
- old_project_id: None,
- user_id: user_context.user_context.user_id.clone(),
- },
- )
- .await;
- }
-
- Ok(project)
-}
diff --git a/services/document_storage_service/src/api/projects/delete_project.rs b/services/document_storage_service/src/api/projects/delete_project.rs
deleted file mode 100644
index 98599c9c6a..0000000000
--- a/services/document_storage_service/src/api/projects/delete_project.rs
+++ /dev/null
@@ -1,381 +0,0 @@
-use crate::api::{context::ApiContext, util::count_occurrences};
-
-use crate::api::context::{AuthorizationService, EntityAccessService};
-use axum::{
- Extension,
- extract::{Path, State},
- http::StatusCode,
- response::{IntoResponse, Response},
-};
-use entity_access::inbound::axum_extractors::ProjectAccessLevelExtractor;
-use macro_authorization::MacroAuthorizationExtractor;
-use model::{
- project::BasicProject,
- response::{
- GenericErrorResponse, GenericResponse, GenericSuccessResponse, SuccessResponse,
- TypedSuccessResponse,
- },
-};
-use models_permissions::share_permission::access_level::OwnerAccessLevel;
-use sqs_client::search::{
- SearchQueueMessage, chat::RemoveChatMessage, document::DocumentId, project::RemoveProject,
-};
-use utoipa::ToSchema;
-
-#[derive(serde::Deserialize)]
-pub struct Params {
- pub id: String,
-}
-
-#[derive(serde::Serialize, serde::Deserialize, Debug, ToSchema)]
-pub struct ProjectDeleteResponseData {
- /// The ids of the project that were marked as deleted
- pub project_ids: Vec<String>,
- /// The ids of the documents that were marked as deleted
- pub document_ids: Vec<String>,
- /// The ids of the chats that were marked as deleted
- pub chat_ids: Vec<String>,
-}
-
-pub type ProjectDeleteResponse = TypedSuccessResponse<ProjectDeleteResponseData>;
-
-/// Deletes a project.
-/// Soft deletes the project and all of its children.
-#[utoipa::path(
- tag = "project",
- delete,
- path = "/projects/{id}",
- params(
- ("id" = String, Path, description = "ID of the project")
- ),
- responses(
- (status = 200, body=inline(ProjectDeleteResponse)),
- (status = 401, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user, id, _access), fields(user_id=?user.macro_user_id, project_id=?id))]
-pub async fn delete_project_handler(
- _access: ProjectAccessLevelExtractor<
- OwnerAccessLevel,
- EntityAccessService,
- AuthorizationService,
- >,
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
- Path(Params { id }): Path<Params>,
- project: Extension<BasicProject>,
-) -> impl IntoResponse {
- tracing::info!("delete project");
-
- let (project_ids, document_ids, chat_ids) =
- match macro_db_client::projects::delete::soft_delete_project(&ctx.db, &id).await {
- Ok(result) => result,
- Err(e) => {
- tracing::error!(error=?e, "unable to delete project");
- return GenericResponse::builder()
- .message("unable to delete project")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- if !project_ids.is_empty() {
- tokio::spawn({
- let sqs_client = ctx.sqs_client.clone();
- let project_ids = project_ids.clone();
- async move {
- let _ = sqs_client
- .bulk_send_message_to_search_event_queue(
- project_ids
- .iter()
- .map(|id| {
- SearchQueueMessage::RemoveProject(RemoveProject {
- project_id: id.to_string(),
- index_override: None,
- })
- })
- .collect(),
- )
- .await
- .inspect_err(
- |e| tracing::error!(error=?e, "unable to enqueue delete projects for search"),
- );
- }
- });
- }
-
- if let Some(parent_id) = &project.parent_id {
- tracing::info!(
- parent_id,
- "sending project update after deleting child project"
- );
- macro_project_utils::update_project_modified(
- &ctx.db,
- Some(ctx.sqs_client.as_ref()),
- macro_project_utils::ProjectModifiedArgs {
- project_id: None,
- old_project_id: Some(parent_id),
- user_id: user.macro_user_id.to_string(),
- },
- )
- .await;
- }
-
- let data = ProjectDeleteResponseData {
- project_ids,
- document_ids,
- chat_ids,
- };
-
- GenericResponse::builder().data(&data).send(StatusCode::OK)
-}
-
-/// Permanently deletes a project and all of it's children.
-#[utoipa::path(
- tag = "project",
- delete,
- operation_id = "permanently_delete_project",
- path = "/projects/{id}/permanent",
- params(
- ("id" = String, Path, description = "ID of the project")
- ),
- responses(
- (status = 200, body=SuccessResponse),
- (status = 401, body=GenericErrorResponse),
- (status = 404, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user, _access), fields(user_id=?user.macro_user_id))]
-pub async fn permanently_delete_project_handler(
- _access: ProjectAccessLevelExtractor<
- OwnerAccessLevel,
- EntityAccessService,
- AuthorizationService,
- >,
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
- Path(Params { id }): Path<Params>,
-) -> Result<Response, Response> {
- tracing::info!("permanently_delete_project");
-
- let mut transaction = match ctx.db.begin().await {
- Ok(transaction) => transaction,
- Err(e) => {
- tracing::error!(error=?e, "unable to begin transaction");
- return Ok(GenericResponse::builder()
- .message("unable to begin transaction")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR));
- }
- };
-
- let project_ids =
- macro_db_client::projects::get_project::get_sub_items::get_all_deleted_sub_project_ids(
- &mut transaction,
- &id,
- )
- .await
- .map_err(|e| {
- tracing::error!(error=?e, "unable to get all deleted sub-project ids");
- GenericResponse::builder()
- .message("unable to get all deleted sub-project ids")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- })?;
-
- let project_ids = project_ids
- .into_iter()
- .map(|(id, _)| id)
- .collect::<Vec<String>>();
- tracing::debug!(project_ids=?project_ids, "deleting project(s)");
-
- let document_ids_and_owner = macro_db_client::projects::get_project::get_project_documents::get_deleted_documents_from_project_ids(&ctx.db, &project_ids).await.map_err(|e| {
- tracing::error!(error=?e, "unable to get deleted documents from project ids");
- GenericResponse::builder()
- .message("unable to get deleted documents from project ids")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- })?;
-
- // using document ids, get all documents that are docx and get their sha counts for
- // decrementing via redis
- let document_ids = document_ids_and_owner
- .iter()
- .map(|(id, _)| id)
- .collect::<Vec<&String>>();
-
- let bom_parts =
- macro_db_client::document::get_bom_parts_bulk_tsx(&mut transaction, &document_ids)
- .await
- .map_err(|e| {
- tracing::error!(error=?e, "unable to get bom parts for documents");
- GenericResponse::builder()
- .message("unable to get bom parts for documents")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- })?;
-
- if !bom_parts.is_empty() {
- tracing::trace!(bom_parts=?bom_parts, "decrementing sha count for bom parts");
- // Transform bom parts into Vec<(sha, count)>
- let sha_counts = count_occurrences(
- bom_parts
- .iter()
- .map(|bp| bp.sha.clone())
- .collect::<Vec<String>>(),
- );
-
- tracing::trace!("decrementing sha ref count");
- ctx.redis_client
- .decrement_counts(&sha_counts)
- .await
- .map_err(|e| {
- tracing::error!(error=?e, "unable to decrement sha ref counts");
- GenericResponse::builder()
- .message("unable to decrement sha ref counts")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- })?;
- }
-
- tracing::debug!(document_ids=?document_ids, "deleting document(s)");
- macro_db_client::document::delete_document_bulk_tsx(&mut transaction, &document_ids)
- .await
- .map_err(|e| {
- tracing::error!(error=?e, "unable to delete documents bulk");
- GenericResponse::builder()
- .message("unable to delete documents bulk")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- })?;
-
- let chat_ids = macro_db_client::projects::get_project::get_project_chats::get_deleted_chats_from_project_ids(&ctx.db, &project_ids).await.map_err(|e| {
- tracing::error!(error=?e, "unable to get deleted chats from project ids");
- GenericResponse::builder()
- .message("unable to get deleted chats from project ids")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- })?;
- let chat_ids = chat_ids
- .into_iter()
- .map(|(id, _)| id)
- .collect::<Vec<String>>();
-
- tracing::debug!(chat_ids=?chat_ids, "deleting chat(s)");
- macro_db_client::chat::delete::delete_chat_bulk_tsx(&mut transaction, &chat_ids)
- .await
- .map_err(|e| {
- tracing::error!(error=?e, "unable to delete chats bulk");
- GenericResponse::builder()
- .message("unable to delete chats bulk")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- })?;
-
- // Deletes all projects in bulk
- macro_db_client::projects::delete::delete_projects_bulk_tsx(&mut transaction, &project_ids)
- .await
- .map_err(|e| {
- tracing::error!(error=?e, "unable to delete projects bulk");
- GenericResponse::builder()
- .message("unable to delete projects bulk")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- })?;
-
- if let Err(e) = transaction.commit().await {
- tracing::error!(error=?e, "unable to commit transaction");
- return Err(GenericResponse::builder()
- .message("unable to commit transaction")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR));
- }
-
- if !project_ids.is_empty() {
- tokio::spawn({
- let sqs_client = ctx.sqs_client.clone();
- let project_ids = project_ids.clone();
- async move {
- let _ = sqs_client
- .bulk_send_message_to_search_event_queue(
- project_ids
- .iter()
- .map(|id| {
- SearchQueueMessage::RemoveProject(RemoveProject {
- project_id: id.to_string(),
- index_override: None,
- })
- })
- .collect(),
- )
- .await
- .inspect_err(
- |e| tracing::error!(error=?e, "unable to enqueue delete projects for search"),
- );
- }
- });
- }
-
- if !chat_ids.is_empty() {
- tokio::spawn({
- let sqs_client = ctx.sqs_client.clone();
- let chat_ids = chat_ids.clone();
- async move {
- let _ = sqs_client
- .bulk_send_message_to_search_event_queue(
- chat_ids
- .iter()
- .map(|id| {
- SearchQueueMessage::RemoveChatMessage(RemoveChatMessage {
- chat_id: id.to_string(),
- message_id: None,
- index_override: None,
- })
- })
- .collect(),
- )
- .await
- .inspect_err(
- |e| tracing::error!(error=?e, "unable to enqueue delete chats for search"),
- );
- }
- });
- }
-
- if !document_ids_and_owner.is_empty() {
- tokio::spawn({
- let sqs_client = ctx.sqs_client.clone();
- let document_ids_and_owner = document_ids_and_owner.clone();
- async move {
- let _ = sqs_client
- .bulk_send_message_to_search_event_queue(
- document_ids_and_owner
- .iter()
- .map(|(id, _)| {
- SearchQueueMessage::RemoveDocument(DocumentId {
- document_id: id.to_string(),
- })
- })
- .collect(),
- )
- .await
- .inspect_err(|e| tracing::error!(error=?e, "unable to enqueue delete documents for search"));
-
- let _ = sqs_client
- .bulk_enqueue_document_delete_with_owner(document_ids_and_owner)
- .await
- .inspect_err(
- |e| tracing::error!(error=?e, "unable to enqueue delete documents"),
- );
- }
- });
- }
-
- let response_data = GenericSuccessResponse { success: true };
-
- Ok(GenericResponse::builder()
- .data(&response_data)
- .send(StatusCode::OK))
-}
diff --git a/services/document_storage_service/src/api/projects/edit_project.rs b/services/document_storage_service/src/api/projects/edit_project.rs
deleted file mode 100644
index 6d95e0640e..0000000000
--- a/services/document_storage_service/src/api/projects/edit_project.rs
+++ /dev/null
@@ -1,277 +0,0 @@
-use crate::api::context::ApiContext;
-use crate::api::context::{AuthorizationService, EntityAccessService};
-use anyhow::Context;
-use axum::{
- Extension,
- extract::{Json, Path, State},
- http::StatusCode,
- response::{IntoResponse, Response},
-};
-use entity_access::domain::models::EntityPermission;
-use entity_access::inbound::axum_extractors::{
- ProjectAccessLevelExtractor, ProjectBodyAccessLevelExtractor,
-};
-use entity_access_management::domain::ports::EntityAccessManagementService;
-use macro_authorization::MacroAuthorizationExtractor;
-use model::response::{GenericErrorResponse, SuccessResponse};
-use model::{project::BasicProject, response::GenericSuccessResponse};
-use model::{project::request::PatchProjectRequestV2, response::ErrorResponse, user::UserContext};
-use models_permissions::share_permission::access_level::{AccessLevel, EditAccessLevel};
-use unicode_segmentation::UnicodeSegmentation;
-
-#[derive(serde::Deserialize)]
-pub struct Params {
- pub id: String,
-}
-
-/// Edits a project.
-#[utoipa::path(
- tag = "project",
- patch,
- operation_id = "edit_project_v2",
- path = "/v2/projects/{id}",
- params(
- ("id" = String, Path, description = "ID of the project")
- ),
- responses(
- (status = 200, body=SuccessResponse),
- (status = 401, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[allow(unused, reason = "used to generate OpenAPI documentation")]
-pub async fn edit_project_handler_v2(
- user: MacroAuthorizationExtractor<AuthorizationService>,
- Path(Params { id }): Path<Params>,
- Json(req): Json<PatchProjectRequestV2>,
-) -> impl IntoResponse {
- StatusCode::OK
-}
-
-/// Edits a project.
-#[tracing::instrument(skip(ctx, user, project, id, access), fields(user_id=?user.macro_user_id, project_id=?id))]
-pub async fn edit_project_handler(
- access: ProjectAccessLevelExtractor<EditAccessLevel, EntityAccessService, AuthorizationService>,
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
- project_context: Extension<BasicProject>,
- Path(Params { id }): Path<Params>,
- project: ProjectBodyAccessLevelExtractor<
- EditAccessLevel,
- PatchProjectRequestV2,
- EntityAccessService,
- >,
-) -> Result<Response, Response> {
- let req = project.into_inner();
-
- if project_context.deleted_at.is_some() {
- return Err((
- StatusCode::BAD_REQUEST,
- Json(ErrorResponse {
- message: "cannot modify deleted project".into(),
- }),
- )
- .into_response());
- }
-
- let access_level = match access.entity_access_receipt.entity_permission() {
- EntityPermission::AccessLevel { access_level } => *access_level,
- _ => AccessLevel::Edit,
- };
-
- edit_project_v2(
- &ctx,
- user.user_context,
- project_context,
- access_level,
- id,
- req,
- )
- .await
- .map_err(|(status_code, message)| {
- tracing::error!(error=?message, "unable to create project");
- (
- status_code,
- Json(GenericErrorResponse {
- error: true,
- message,
- }),
- )
- .into_response()
- })?;
-
- return Ok((
- StatusCode::OK,
- Json(SuccessResponse {
- error: false,
- data: GenericSuccessResponse::default(),
- }),
- )
- .into_response());
-}
-
-async fn edit_project_v2(
- ctx: &ApiContext,
- user_context: UserContext,
- project_context: Extension<BasicProject>,
- users_access_level: AccessLevel,
- id: String,
- req: PatchProjectRequestV2,
-) -> Result<(), (StatusCode, String)> {
- if let Some(name) = req.name.as_ref()
- && name.graphemes(true).count() > 100
- {
- return Err((StatusCode::BAD_REQUEST, "name too long".to_string()));
- }
-
- // Need to ensure we are not nesting the project
- if let Some(project_parent_id) = req.project_parent_id.as_ref() {
- if users_access_level != AccessLevel::Owner {
- return Err((
- StatusCode::UNAUTHORIZED,
- "you do not have valid permissions to move this item".to_string(),
- ));
- }
-
- if project_parent_id == &id {
- tracing::warn!("project parent id matches project id");
- return Err((
- StatusCode::BAD_REQUEST,
- "project parent id matches project id".to_string(),
- ));
- }
- // An empty parent id clears the parent, so there is no nesting to check
- if !project_parent_id.is_empty() {
- match macro_db_client::projects::nested_projects::is_project_recursively_nested(
- ctx.db.clone(),
- id.as_str(),
- project_parent_id.as_str(),
- )
- .await
- {
- Ok(e) => {
- if e.is_some() {
- tracing::warn!(error=?e, "project is recursively nested");
- return Err((
- StatusCode::BAD_REQUEST,
- "project is recursively nested".to_string(),
- ));
- }
- }
- Err(e) => {
- tracing::error!(error=?e, "unable to check if project is recursively nested");
- return Err((
- StatusCode::INTERNAL_SERVER_ERROR,
- "error checking if project is recursively nested".to_string(),
- ));
- }
- };
- }
- }
-
- if req.share_permission.is_some() && users_access_level != AccessLevel::Owner {
- return Err((
- StatusCode::UNAUTHORIZED,
- "you do not have valid permission to modify share permissions".to_string(),
- ));
- }
-
- if let Err(err) = patch_project_transaction(
- ctx,
- &user_context,
- &id,
- &project_context,
- req.name.as_deref(),
- req.project_parent_id.as_deref(),
- req.share_permission.as_ref(),
- )
- .await
- {
- tracing::error!(error=?err, "Failed to patch project");
- return Err((
- StatusCode::INTERNAL_SERVER_ERROR,
- "unable to patch project".to_string(),
- ));
- }
-
- // Update the project you are editting
- macro_project_utils::update_project_modified(
- &ctx.db,
- Some(ctx.sqs_client.as_ref()),
- macro_project_utils::ProjectModifiedArgs {
- project_id: Some(id.clone()), // The project you edited
- old_project_id: None,
- user_id: user_context.user_id.clone(),
- },
- )
- .await;
-
- let _ = ctx
- .entity_access_management_service
- .move_project(
- &macro_uuid::string_to_uuid(&id).unwrap(),
- project_context
- .parent_id
- .as_ref()
- .map(|p| macro_uuid::string_to_uuid(p).unwrap())
- .as_ref(),
- req.project_parent_id
- .as_ref()
- // An empty parent id clears the parent
- .filter(|p| !p.is_empty())
- .map(|p| macro_uuid::string_to_uuid(p).unwrap())
- .as_ref(),
- )
- .await
- .inspect_err(|e| tracing::error!(error=?e, "unable to update entity access for project"));
-
- // Update the project you moved from and moved to
- macro_project_utils::update_project_modified(
- &ctx.db,
- Some(ctx.sqs_client.as_ref()),
- macro_project_utils::ProjectModifiedArgs {
- project_id: req.project_parent_id, // The new project you've placed your item in
- old_project_id: project_context.parent_id.clone(), // The old project you've moved your item from
- user_id: user_context.user_id.clone(),
- },
- )
- .await;
-
- Ok(())
-}
-
-#[tracing::instrument(skip(ctx, user_context))]
-async fn patch_project_transaction(
- ctx: &ApiContext,
- user_context: &UserContext,
- project_id: &str,
- project_context: &BasicProject,
- name: Option<&str>,
- project_parent_id: Option<&str>,
- share_permission: Option<&models_permissions::share_permission::UpdateSharePermissionRequestV2>,
-) -> anyhow::Result<()> {
- let mut transaction = ctx
- .db
- .begin()
- .await
- .context("failed to begin transaction")?;
-
- // Update project metadata
- macro_db_client::projects::edit_project_v2(
- &mut transaction,
- &user_context.user_id,
- project_id,
- name,
- project_parent_id,
- share_permission,
- )
- .await
- .context("failed to patch project")?;
-
- transaction
- .commit()
- .await
- .context("failed to commit transaction")?;
-
- Ok(())
-}
diff --git a/services/document_storage_service/src/api/projects/get_batch_preview.rs b/services/document_storage_service/src/api/projects/get_batch_preview.rs
deleted file mode 100644
index c0046bda7f..0000000000
--- a/services/document_storage_service/src/api/projects/get_batch_preview.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-use std::collections::HashSet;
-
-use crate::api::context::{ApiContext, AuthorizationService};
-use anyhow::Result;
-use axum::{
- extract::{Json, State},
- response::{IntoResponse, Response},
-};
-use macro_authorization::OptionalMacroAuthorizationExtractor;
-use model::{
- project::{
- ProjectPreview, ProjectPreviewData, ProjectPreviewV2, WithProjectId,
- request::GetBatchProjectPreviewRequest, response::GetBatchProjectPreviewResponse,
- },
- response::{GenericErrorResponse, GenericResponse},
-};
-use reqwest::StatusCode;
-
-#[tracing::instrument(skip(ctx, user, req), fields(user_id=?user.macro_user_id))]
-#[utoipa::path(
- tag = "project",
- post,
- path = "/projects/preview",
- responses(
- (status = 200, body=GetBatchProjectPreviewResponse),
- (status = 401, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- ),
- operation_id = "get_batch_project_preview"
-)]
-pub async fn get_batch_preview_handler(
- State(ctx): State<ApiContext>,
- user: OptionalMacroAuthorizationExtractor<AuthorizationService>,
- Json(req): Json<GetBatchProjectPreviewRequest>,
-) -> Result<(StatusCode, Json<GetBatchProjectPreviewResponse>), Response> {
- // Ensure the project ids are unique to prevent duplicate work
- let unique_project_ids: HashSet<String> = req.project_ids.iter().cloned().collect();
- let project_ids: Vec<String> = unique_project_ids.into_iter().collect();
-
- let project_preview_results =
- macro_db_client::projects::preview::batch_get_project_preview_v2(&ctx.db, &project_ids)
- .await
- .map_err(|err| {
- tracing::error!(error=?err, "unable to get project preview");
- GenericResponse::builder()
- .message("failed to retrieve project previews")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- .into_response()
- })?;
-
- let result: Vec<ProjectPreview> = project_preview_results
- .iter()
- .map(|p| match p {
- ProjectPreviewV2::Found(data) => ProjectPreview::Access(ProjectPreviewData {
- id: data.id.clone(),
- name: data.name.clone(),
- owner: data.owner.clone(),
- path: data.path.clone(),
- updated_at: data.updated_at,
- }),
- ProjectPreviewV2::DoesNotExist(data) => ProjectPreview::DoesNotExist(WithProjectId {
- id: data.id.clone(),
- }),
- })
- .collect();
-
- Ok((
- StatusCode::OK,
- Json(GetBatchProjectPreviewResponse { previews: result }),
- ))
-}
diff --git a/services/document_storage_service/src/api/projects/get_project.rs b/services/document_storage_service/src/api/projects/get_project.rs
deleted file mode 100644
index c7f3e35273..0000000000
--- a/services/document_storage_service/src/api/projects/get_project.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-use crate::api::context::ApiContext;
-
-use crate::api::context::{AuthorizationService, EntityAccessService};
-use axum::Json;
-use axum::extract::State;
-use axum::response::Response;
-use axum::{extract::Path, http::StatusCode, response::IntoResponse};
-use entity_access::domain::models::EntityPermission;
-use entity_access::inbound::axum_extractors::ProjectAccessLevelExtractor;
-use macro_authorization::MacroAuthorizationExtractor;
-use model::project::response::{
- GetProjectContentResponse, GetProjectResponse, GetProjectResponseData,
-};
-use model::response::{ErrorResponse, GenericErrorResponse, GenericResponse};
-use models_permissions::share_permission::access_level::AccessLevel;
-use models_permissions::share_permission::access_level::ViewAccessLevel;
-use sqlx::PgPool;
-
-#[derive(serde::Deserialize)]
-pub struct Params {
- pub id: String,
-}
-
-/// Gets the content of a project.
-/// This includes the projects sub-projects as well as the items in the project.
-#[utoipa::path(
- tag = "project",
- get,
- path = "/projects/{id}/content",
- params(
- ("id" = String, Path, description = "ID of the project")
- ),
- responses(
- (status = 200, body=GetProjectContentResponse),
- (status = 401, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(db, user_context, id, access), fields(user_id=?user_context.macro_user_id, project_id=?id))]
-pub async fn get_project_content_handler(
- access: ProjectAccessLevelExtractor<ViewAccessLevel, EntityAccessService, AuthorizationService>,
- State(db): State<PgPool>,
- user_context: MacroAuthorizationExtractor<AuthorizationService>,
- Path(Params { id }): Path<Params>,
-) -> Result<Response, Response> {
- let access_level = match access.entity_access_receipt.entity_permission() {
- EntityPermission::AccessLevel { access_level } => *access_level,
- _ => AccessLevel::View,
- };
-
- let content = macro_db_client::projects::get_project::get_project_content_v2(
- &db,
- id.as_str(),
- user_context.macro_user_id,
- access_level,
- )
- .await
- .map_err(|e| {
- tracing::error!(error=?e, "unable to get project content");
- (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(ErrorResponse {
- message: "unable to get project content".into(),
- }),
- )
- .into_response()
- })?;
-
- Ok(GenericResponse::builder()
- .data(&content)
- .send(StatusCode::OK))
-}
-
-#[utoipa::path(
- get,
- path = "/projects/{id}",
- params(
- ("id" = String, Path, description = "ID of the project")
- ),
- responses(
- (status = 200, body=GetProjectResponse),
- (status = 401, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
-)]
-#[tracing::instrument(skip(ctx, user, id, access), fields(user_id=?user.macro_user_id, project_id=?id))]
-pub async fn get_project_handler(
- access: ProjectAccessLevelExtractor<ViewAccessLevel, EntityAccessService, AuthorizationService>,
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
- Path(Params { id }): Path<Params>,
-) -> Result<Response, Response> {
- let project_metadata =
- macro_db_client::projects::get_project::get_project_by_id(ctx.db.clone(), id.as_str())
- .await
- .map_err(|e| {
- tracing::error!(error=?e, "unable to get project");
- (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(ErrorResponse {
- message: "unable to get project".into(),
- }),
- )
- .into_response()
- })?;
-
- let user_access_level = match access.entity_access_receipt.entity_permission() {
- EntityPermission::AccessLevel { access_level } => *access_level,
- _ => AccessLevel::View,
- };
-
- let response_data = GetProjectResponseData {
- project_metadata,
- user_access_level,
- };
-
- Ok(GenericResponse::builder()
- .data(&response_data)
- .send(StatusCode::OK))
-}
diff --git a/services/document_storage_service/src/api/projects/get_projects.rs b/services/document_storage_service/src/api/projects/get_projects.rs
deleted file mode 100644
index fda7e9a7bc..0000000000
--- a/services/document_storage_service/src/api/projects/get_projects.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-use crate::api::context::{ApiContext, AuthorizationService};
-
-use axum::extract::State;
-use futures::stream::{FuturesUnordered, StreamExt};
-
-use axum::{http::StatusCode, response::IntoResponse};
-use macro_authorization::MacroAuthorizationExtractor;
-use model::project::PendingProject;
-use model::project::response::GetProjectsResponse;
-use model::response::{GenericErrorResponse, GenericResponse, TypedSuccessResponse};
-use models_bulk_upload::ProjectDocumentStatus;
-
-type PendingProjectsResponse = TypedSuccessResponse<Vec<PendingProject>>;
-
-/// Gets all the users projects. This includes projects shared with the user.
-#[utoipa::path(
- tag = "project",
- get,
- path = "/projects",
- responses(
- (status = 200, body=GetProjectsResponse),
- (status = 401, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user), fields(user_id=?user.macro_user_id))]
-pub async fn get_projects_handler(
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
-) -> impl IntoResponse {
- tracing::trace!("get_projects_handler");
- let projects =
- match macro_db_client::projects::get_projects(ctx.db.clone(), user.macro_user_id.as_ref())
- .await
- {
- Ok(projects) => projects,
- Err(e) => {
- tracing::error!(error=?e, "error getting projects");
- return GenericResponse::builder()
- .message("unable to get projects")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- GenericResponse::builder()
- .data(&projects)
- .send(StatusCode::OK)
-}
-
-/// Gets all the users projects that are pending upload. This includes projects shared with the user.
-#[utoipa::path(
- tag = "project",
- get,
- path = "/projects/pending",
- responses(
- (status = 200, body=inline(PendingProjectsResponse)),
- (status = 401, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user), fields(user_id=?user.macro_user_id))]
-pub async fn get_pending_projects_handler(
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
-) -> impl IntoResponse {
- tracing::trace!("get_pending_projects_handler");
- let projects = match macro_db_client::projects::get_pending_root_projects(
- ctx.db.clone(),
- user.macro_user_id.as_ref(),
- )
- .await
- {
- Ok(projects) => projects,
- Err(e) => {
- tracing::error!(error=?e, "error getting projects");
- return GenericResponse::builder()
- .message("unable to get projects")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- let mut futures = FuturesUnordered::new();
-
- for pending_project in projects {
- let project = pending_project.project;
-
- // only build status for root projects
- if project.parent_id.is_some() {
- tracing::warn!("Skipping pending project with parent_id: {}", project.id);
- continue;
- }
-
- let dynamodb_client = ctx.dynamodb_client.clone();
- let upload_request_id = pending_project.upload_request_id;
- futures.push(async move {
- let result: anyhow::Result<PendingProject> = if let Some(upload_request_id) = upload_request_id {
- let document_statuses: Vec<ProjectDocumentStatus> = match dynamodb_client
- .bulk_upload
- .get_bulk_upload_document_statuses(&upload_request_id)
- .await {
- Ok(status_result) => {
- if status_result.documents.is_empty() {
- tracing::warn!("No documents found for upload request {}", upload_request_id);
- } else if status_result.root_project_id != project.id {
- anyhow::bail!("Root project ID mismatch for upload request {}. DynamoDB project {}. Provided project {}", upload_request_id, status_result.root_project_id, project.id);
- }
-
- status_result.documents
- }
- Err(e) => {
- tracing::error!(error=?e, "Error getting document statuses for project {}", project.id);
- vec![]
- }
- };
-
- Ok(PendingProject {
- project,
- document_statuses
- })
- } else {
- tracing::warn!("No upload request found for project {}", project.id);
- Ok(PendingProject {
- project,
- document_statuses: vec![],
- })
- };
-
- result
- });
- }
-
- let mut projects: Vec<PendingProject> = Vec::new();
- while let Some(res) = futures.next().await {
- match res {
- Ok(project) => projects.push(project),
- Err(e) => {
- tracing::error!(error=?e, "Error getting pending project info");
- }
- }
- }
-
- GenericResponse::builder()
- .data(&projects)
- .send(StatusCode::OK)
-}
diff --git a/services/document_storage_service/src/api/projects/mod.rs b/services/document_storage_service/src/api/projects/mod.rs
deleted file mode 100644
index 1ee5dfd133..0000000000
--- a/services/document_storage_service/src/api/projects/mod.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-use super::context::ApiContext;
-use axum::{
- Router,
- routing::{delete, get, patch, post, put},
-};
-use macro_middleware::cloud_storage::project::ensure_project_exists;
-
-pub(in crate::api) mod create_project;
-pub(in crate::api) mod delete_project;
-pub(in crate::api) mod edit_project;
-pub(in crate::api) mod get_batch_preview;
-pub(in crate::api) mod get_project;
-pub(in crate::api) mod get_projects;
-pub(in crate::api) mod project_permission;
-pub(in crate::api) mod revert_delete_project;
-pub(in crate::api) mod upload_folder;
-
-pub fn router(state: ApiContext) -> Router<ApiContext> {
- let ensure_project_exists_middleware =
- axum::middleware::from_fn_with_state(state.clone(), ensure_project_exists::handler);
- Router::new()
- .route("/", get(get_projects::get_projects_handler))
- .route("/pending", get(get_projects::get_pending_projects_handler))
- .route(
- "/{id}/permissions",
- get(project_permission::get_project_permissions_handler)
- .layer(ensure_project_exists_middleware.clone()),
- )
- .route(
- "/{id}/access_level",
- get(project_permission::get_project_access_level_handler)
- .layer(ensure_project_exists_middleware.clone()),
- )
- .route(
- "/{id}/content",
- get(get_project::get_project_content_handler)
- .layer(ensure_project_exists_middleware.clone()),
- )
- .route("/", post(create_project::create_project_handler))
- .route("/upload", post(upload_folder::upload_folder_handler))
- .route(
- "/upload_extract",
- post(upload_folder::upload_extract_folder_handler),
- )
- .route(
- "/{id}",
- patch(edit_project::edit_project_handler)
- .layer(ensure_project_exists_middleware.clone()),
- )
- .route(
- "/{id}/revert_delete",
- put(revert_delete_project::handler).layer(ensure_project_exists_middleware.clone()),
- )
- .route(
- "/{id}",
- delete(delete_project::delete_project_handler)
- .layer(ensure_project_exists_middleware.clone()),
- )
- .route(
- "/{id}/permanent",
- delete(delete_project::permanently_delete_project_handler)
- .layer(ensure_project_exists_middleware.clone()),
- )
- .route(
- "/{id}",
- get(get_project::get_project_handler).layer(ensure_project_exists_middleware),
- )
- .route(
- "/preview",
- post(get_batch_preview::get_batch_preview_handler),
- )
-}
diff --git a/services/document_storage_service/src/api/projects/project_permission.rs b/services/document_storage_service/src/api/projects/project_permission.rs
deleted file mode 100644
index 7a93cf0309..0000000000
--- a/services/document_storage_service/src/api/projects/project_permission.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-use crate::api::context::ApiContext;
-use crate::api::context::{AuthorizationService, EntityAccessService};
-use axum::extract::State;
-use axum::response::Response;
-use axum::{
- extract::Path,
- http::StatusCode,
- response::{IntoResponse, Json},
-};
-use entity_access::domain::ports::EntityAccessService as EntityAccessServiceTrait;
-use entity_access::inbound::axum_extractors::ProjectAccessLevelExtractor;
-use macro_authorization::MacroAuthorizationExtractor;
-use model::response::GenericErrorResponse;
-use model_entity::EntityType;
-use models_permissions::share_permission::SharePermissionV2;
-use models_permissions::share_permission::access_level::{AccessLevel, OwnerAccessLevel};
-
-#[derive(serde::Deserialize)]
-pub struct Params {
- pub id: String,
-}
-
-/// Gets the current documents share permissions
-/// Gets the projects share permissions
-#[utoipa::path(
- tag = "project",
- get,
- path = "/projects/{id}/permissions",
- operation_id = "get_project_permissions_v2",
- params(
- ("id" = String, Path, description = "ID of the project")
- ),
- responses(
- (status = 200, body=SharePermissionV2),
- (status = 404, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user, id, _access), fields(user_id=?user.macro_user_id, project_id=?id))]
-pub async fn get_project_permissions_handler(
- State(ctx): State<ApiContext>,
- _access: ProjectAccessLevelExtractor<
- OwnerAccessLevel,
- EntityAccessService,
- AuthorizationService,
- >,
- user: MacroAuthorizationExtractor<AuthorizationService>,
- Path(Params { id }): Path<Params>,
-) -> Result<Response, Response> {
- get_project_permission_v2(&ctx.db, &id).await
-}
-
-async fn get_project_permission_v2(
- db: &sqlx::Pool<sqlx::Postgres>,
- project_id: &str,
-) -> Result<Response, Response> {
- let project_permissions = macro_db_client::share_permission::get::get_project_share_permission(
- db, project_id,
- )
- .await
- .map_err(|e| {
- tracing::error!(error=?e, project_id=?project_id, "unable to get project permissions");
- (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(GenericErrorResponse {
- error: true,
- message: "unable to get project permissions".to_string(),
- }),
- )
- .into_response()
- })?;
-
- Ok((StatusCode::OK, Json(project_permissions)).into_response())
-}
-
-/// Gets the user's access level to the project
-#[utoipa::path(
- tag = "project",
- get,
- path = "/projects/{id}/access_level",
- operation_id = "get_project_user_access_level",
- params(
- ("id" = String, Path, description = "ID of the project")
- ),
- responses(
- (status = 200, body=AccessLevel),
- (status = 401, body=GenericErrorResponse),
- (status = 404, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user), fields(user_id=?user.macro_user_id))]
-pub async fn get_project_access_level_handler(
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
- Path(Params { id }): Path<Params>,
-) -> impl IntoResponse {
- let user_access_level: Option<AccessLevel> = match ctx
- .entity_access_service
- .get_access_level(Some(&user.macro_user_id), &id, EntityType::Project)
- .await
- {
- Ok(user_access_level) => user_access_level,
- Err(e) => {
- tracing::error!(error=?e, "failed to get user access level");
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(GenericErrorResponse {
- error: true,
- message: "failed to get user access level".to_string(),
- }),
- )
- .into_response();
- }
- };
-
- let user_access_level = if let Some(user_access_level) = user_access_level {
- user_access_level
- } else {
- tracing::warn!("user does not have access to project");
- return (
- StatusCode::INTERNAL_SERVER_ERROR,
- Json(GenericErrorResponse {
- error: true,
- message: "user does not have access to project".to_string(),
- }),
- )
- .into_response();
- };
-
- (StatusCode::OK, Json(user_access_level)).into_response()
-}
diff --git a/services/document_storage_service/src/api/projects/revert_delete_project.rs b/services/document_storage_service/src/api/projects/revert_delete_project.rs
deleted file mode 100644
index 49a6ad0b0e..0000000000
--- a/services/document_storage_service/src/api/projects/revert_delete_project.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-use crate::api::context::{ApiContext, AuthorizationService};
-use axum::extract::State;
-use axum::{Extension, extract::Path, http::StatusCode, response::IntoResponse};
-#[allow(unused_imports)]
-use futures::stream::TryStreamExt;
-use macro_authorization::MacroAuthorizationExtractor;
-use model::project::BasicProject;
-use model::response::{
- GenericErrorResponse, GenericResponse, GenericSuccessResponse, SuccessResponse,
-};
-use sqs_client::search::{SearchQueueMessage, project::UpsertProject};
-
-#[derive(serde::Deserialize)]
-pub struct Params {
- pub id: String,
-}
-
-/// Deletes a specific document
-#[utoipa::path(
- tag = "project",
- put,
- operation_id = "revert_delete_project",
- path = "/projects/{id}/revert_delete",
- params(
- ("id" = String, Path, description = "ID of the project")
- ),
- responses(
- (status = 200, body=SuccessResponse),
- (status = 401, body=GenericErrorResponse),
- (status = 404, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user, project_context, id), fields(user_id=?user.macro_user_id, project_id=?id))]
-pub async fn handler(
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
- Path(Params { id }): Path<Params>,
- project_context: Extension<BasicProject>,
-) -> impl IntoResponse {
- tracing::info!("revert_delete project");
-
- let project_ids = match macro_db_client::projects::revert_delete::revert_delete_project(
- &ctx.db,
- &id,
- project_context.parent_id.as_deref(),
- )
- .await
- {
- Ok(project_ids) => project_ids,
- Err(e) => {
- tracing::error!(error=?e, "unable to revert project");
- return GenericResponse::builder()
- .message("unable to revert project")
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- if !project_ids.is_empty() {
- tokio::spawn({
- let sqs_client = ctx.sqs_client.clone();
- async move {
- let _ = sqs_client
- .bulk_send_message_to_search_event_queue(
- project_ids
- .iter()
- .map(|id| {
- SearchQueueMessage::UpsertProject(UpsertProject {
- project_id: id.to_string(),
- index_override: None,
- })
- })
- .collect(),
- )
- .await
- .inspect_err(
- |e| tracing::error!(error=?e, "unable to enqueue restored projects for search"),
- );
- }
- });
- }
-
- let data = GenericSuccessResponse::default();
-
- GenericResponse::builder().data(&data).send(StatusCode::OK)
-}
diff --git a/services/document_storage_service/src/api/projects/upload_folder.rs b/services/document_storage_service/src/api/projects/upload_folder.rs
deleted file mode 100644
index e6be059488..0000000000
--- a/services/document_storage_service/src/api/projects/upload_folder.rs
+++ /dev/null
@@ -1,429 +0,0 @@
-use crate::{
- api::context::{ApiContext, AuthorizationService, InternalFlag},
- service::{self},
-};
-use anyhow::Context;
-use axum::{
- Extension, Json,
- extract::{self, State},
- http::StatusCode,
- response::IntoResponse,
-};
-use macro_authorization::MacroAuthorizationExtractor;
-use macro_user_id::user_id::MacroUserIdStr;
-use model::{
- document::{ContentType, DocumentMetadata, FileType},
- folder::{
- FileSystemNode, S3Destination, S3DestinationMap, UploadFolderRequest,
- UploadFolderResponseData, UploadFolderWithIdsResponse,
- },
- response::{GenericErrorResponse, GenericResponse, PresignedUrl, TypedSuccessResponse},
-};
-use models_bulk_upload::{
- MarkProjectUploadedRequest, MarkProjectUploadedResponse, S3ObjectInfo,
- UploadExtractFolderRequest, UploadExtractFolderResponseData,
-};
-use models_permissions::share_permission::SharePermissionV2;
-use s3_key::{build_cloud_storage_bucket_document_key, build_docx_staging_bucket_document_key};
-use sqlx::{Pool, Postgres};
-use sqs_client::search::{SearchQueueMessage, project::UpsertProject};
-use std::{str::FromStr, sync::Arc};
-use uuid::Uuid;
-
-type UploadExtractFolderResponse = TypedSuccessResponse<UploadExtractFolderResponseData>;
-type UploadFolderResponse = TypedSuccessResponse<UploadFolderResponseData>;
-
-/// Creates a request id in the dynamodb table for tracking the upload
-/// Returns a presigned url for uploading a zip file to the staging bucket
-/// Returns a request id for tracking the upload
-#[utoipa::path(
- tag = "project",
- post,
- path = "/projects/upload_extract",
- responses(
- (status = 200, body=inline(UploadExtractFolderResponse)),
- (status = 401, body=GenericErrorResponse),
- (status = 404, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user, req), fields(user_id=?user.macro_user_id))]
-pub async fn upload_extract_folder_handler(
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
- extract::Json(req): extract::Json<UploadExtractFolderRequest>,
-) -> impl IntoResponse {
- let user_id = user.macro_user_id.as_ref();
- let name = req.name.as_deref();
-
- // use local request id for local development
- // (used by bulk upload lambda test events)
- let request_id = if cfg!(feature = "local") {
- tracing::info!("using local request id");
- "d50676e2-0a12-4c62-bc07-4b1cb6d8e9bc".to_string()
- } else {
- Uuid::new_v4().to_string()
- };
-
- tracing::debug!("upload extract: request id {}, name {:?}", request_id, name);
- let maybe_request = ctx
- .dynamodb_client
- .bulk_upload
- .create_bulk_upload_request(request_id.as_str(), user_id, name, req.parent_id.as_deref())
- .await;
-
- let request = match maybe_request {
- Ok(request) => request,
- Err(e) => {
- tracing::error!(error=?e, "unable to create bulk upload request");
- return GenericResponse::builder()
- .message(&format!("unable to create bulk upload request: {}", e))
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- let presigned_url = match ctx
- .s3_client
- .put_upload_zip_staging_presigned_url(request.key.as_str(), req.sha.as_str())
- .await
- {
- Ok(presigned_url) => presigned_url,
- Err(e) => {
- tracing::error!(error=?e, "unable to create presigned url");
- return GenericResponse::builder()
- .message(&format!("unable to create presigned url: {}", e))
- .is_error(true)
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- let data = UploadExtractFolderResponseData {
- request_id,
- presigned_url,
- };
-
- return GenericResponse::builder().data(&data).send(StatusCode::OK);
-}
-
-/// Uploads a folder to the user's cloud storage. Mimicing the folder structure
-/// with projects and placing all documents in the correct location.
-#[utoipa::path(
- post,
- path = "/projects/upload",
- responses(
- (status = 200, body=inline(UploadFolderResponse)),
- (status = 401, body=GenericErrorResponse),
- (status = 404, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user_context, req), fields(user_id=%user_context.macro_user_id))]
-pub async fn upload_folder_handler(
- State(ctx): State<ApiContext>,
- user_context: MacroAuthorizationExtractor<AuthorizationService>,
- internal_context: Option<Extension<InternalFlag>>,
- extract::Json(req): extract::Json<UploadFolderRequest>,
-) -> impl IntoResponse {
- let internal = internal_context.is_some_and(|state| state.internal);
- upload_folder_handler_inner(
- ctx.s3_client.clone(),
- ctx.db.clone(),
- ctx.sqs_client.clone(),
- user_context.macro_user_id,
- internal,
- req,
- )
- .await
-}
-
-// recursively iterates through the folder structure and generates nested projects
-// with empty documents in the database
-// optionally returns a list of presigned urls for each document for uploading
-async fn upload_folder_handler_inner(
- s3_client: Arc<service::s3::S3>,
- db: Pool<Postgres>,
- sqs_client: Arc<sqs_client::SQS>,
- user_id: MacroUserIdStr<'static>,
- internal: bool,
- req: UploadFolderRequest,
-) -> impl IntoResponse + use<> {
- let file_system = match FileSystemNode::build_file_system(&req.root_folder_name, req.content) {
- Ok(fs) => fs,
- Err(err) => {
- tracing::error!(error=?err, "unable to build file system");
- return GenericResponse::builder()
- .is_error(true)
- .message(&format!("unable to build file system: {}", err))
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
- let root_folder = match file_system.get_root_folder(&req.root_folder_name) {
- Ok(root_folder) => root_folder,
- Err(err) => {
- tracing::error!(error=?err, "unable to get root folder");
- return GenericResponse::builder()
- .is_error(true)
- .message(&format!("unable to get root folder: {}", err))
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- let share_permission = SharePermissionV2::new_project_share_permission();
-
- let mut transaction = match db.begin().await {
- Ok(transaction) => transaction,
- Err(err) => {
- tracing::error!(error=?err, "error starting transaction");
- return GenericResponse::builder()
- .is_error(true)
- .message(&format!("unable to start transaction: {}", err))
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- let UploadFolderWithIdsResponse {
- file_system,
- project_ids,
- documents,
- } = match macro_db_client::projects::upload_folder::upload_folder_with_ids(
- &mut transaction,
- user_id.clone(),
- &share_permission,
- root_folder,
- &req.root_folder_name,
- &req.upload_request_id,
- req.parent_id.as_deref(),
- )
- .await
- {
- Ok(res) => res,
- Err(err) => {
- tracing::error!(error=?err, "error uploading folder");
- return GenericResponse::builder()
- .is_error(true)
- .message(&format!("unable to upload folder: {}", err))
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- tracing::trace!(documents=?documents, "got documents to upload");
-
- let destination_map = match build_documents(&s3_client, &documents, internal).await {
- Ok(res) => res,
- Err(err) => {
- tracing::error!(error=?err, "error building s3 destination map");
- cleanup(
- db.clone(),
- user_id.as_ref(),
- &project_ids,
- &documents
- .iter()
- .map(|doc| doc.document_id.clone())
- .collect(),
- )
- .await;
-
- return GenericResponse::builder()
- .is_error(true)
- .message(&format!("unable to build presigned urls: {}", err))
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
- };
-
- // Commit transaction at the end so we can auto rollback if user cancels connection
- if let Err(e) = transaction.commit().await {
- tracing::error!(error=?e, "error committing transaction");
- cleanup(
- db.clone(),
- user_id.as_ref(),
- &project_ids,
- &documents
- .iter()
- .map(|doc| doc.document_id.clone())
- .collect(),
- )
- .await;
-
- return GenericResponse::builder()
- .is_error(true)
- .message(&format!("unable to save folder contents to db: {}", e))
- .send(StatusCode::INTERNAL_SERVER_ERROR);
- }
-
- if !project_ids.is_empty() {
- tokio::spawn({
- let sqs_client = sqs_client.clone();
- let project_ids = project_ids.clone();
- async move {
- let _ = sqs_client
- .bulk_send_message_to_search_event_queue(
- project_ids
- .iter()
- .map(|id| {
- SearchQueueMessage::UpsertProject(UpsertProject {
- project_id: id.to_string(),
- index_override: None,
- })
- })
- .collect(),
- )
- .await
- .inspect_err(
- |e| tracing::error!(error=?e, "unable to enqueue uploaded projects for search"),
- );
- }
- });
- }
-
- let data = UploadFolderResponseData {
- file_system,
- destination_map,
- };
-
- GenericResponse::builder().data(&data).send(StatusCode::OK)
-}
-
-async fn build_documents(
- s3_client: &service::s3::S3,
- documents: &Vec<DocumentMetadata>,
- internal: bool,
-) -> anyhow::Result<S3DestinationMap> {
- let mut result: S3DestinationMap = S3DestinationMap::new();
- for document in documents {
- tracing::trace!(document_id=?document.document_id, document_name=?document.document_name, "inserting document into mapping table");
- let file_type: Option<FileType> = document
- .file_type
- .as_deref()
- .map(FileType::from_str)
- .transpose()?;
- let sha = document.sha.clone().context("document needs a sha")?;
- if file_type != Some(FileType::Docx) {
- let key = build_cloud_storage_bucket_document_key(
- document.owner.as_ref(),
- &document.document_id,
- document.document_version_id,
- );
-
- match internal {
- false => {
- let presigned_url: String = match file_type {
- Some(FileType::Docx) => s3_client.put_docx_upload_presigned_url(key.as_str(), sha.as_str(), ContentType::Docx).await.map_err(|err| {
- tracing::error!(error=?err, key=?key, document_id=?document.document_id, "unable to generate presigned url");
- err
- })?,
- _ => s3_client.put_document_storage_presigned_url(key.as_str(), sha.as_str(), file_type.into()).await.map_err(|err| {
- tracing::error!(error=?err, key=?key, document_id=?document.document_id, "unable to generate presigned url");
- err
- })?,
- };
-
- result.insert(
- document.document_id.clone(),
- S3Destination::External(PresignedUrl { sha, presigned_url }),
- );
- }
- true => {
- let s3_object_info = S3ObjectInfo {
- bucket: s3_client.get_document_storage_bucket().to_string(),
- key,
- };
- result.insert(
- document.document_id.clone(),
- S3Destination::Internal(s3_object_info),
- );
- }
- };
- } else {
- if !internal {
- tracing::warn!("External destination not implemented for docx upload");
- continue;
- }
-
- let key = build_docx_staging_bucket_document_key(
- document.owner.as_ref(),
- &document.document_id,
- document.document_version_id,
- );
- let s3_object_info = S3ObjectInfo {
- bucket: s3_client.get_docx_upload_bucket().to_string(),
- key,
- };
- result.insert(
- document.document_id.clone(),
- S3Destination::Internal(s3_object_info),
- );
- }
- }
-
- Ok(result)
-}
-
-/// NOTE: internal only
-///
-/// handler for marking a folder (and all its children) as uploaded
-#[utoipa::path(
- post,
- path = "/projects/mark_uploaded",
- responses(
- (status = 200, body=MarkProjectUploadedResponse),
- (status = 401, body=GenericErrorResponse),
- (status = 404, body=GenericErrorResponse),
- (status = 500, body=GenericErrorResponse),
- )
- )]
-#[tracing::instrument(skip(ctx, user))]
-pub async fn mark_uploaded_handler(
- State(ctx): State<ApiContext>,
- user: MacroAuthorizationExtractor<AuthorizationService>,
- extract::Json(req): extract::Json<MarkProjectUploadedRequest>,
-) -> impl IntoResponse {
- let user_id = user.macro_user_id.as_ref();
- let root_project_id = req.project_id;
-
- match macro_db_client::projects::upload_folder::mark_projects_uploaded(
- ctx.db.clone(),
- user_id,
- &root_project_id,
- )
- .await
- {
- Ok(project_ids) => {
- tracing::debug!(project_ids=?project_ids, "marked projects as uploaded");
- let data = MarkProjectUploadedResponse { project_ids };
- (StatusCode::OK, Json(data)).into_response()
- }
- Err(e) => {
- tracing::error!(error=?e, project_id=?root_project_id, "error marking projects as uploaded");
- GenericResponse::builder()
- .is_error(true)
- .message(&format!("Error marking projects as uploaded: {}", e))
- .send(StatusCode::INTERNAL_SERVER_ERROR)
- }
- }
-}
-
-/// Performs cleanup of a partially uploaded folder.
-#[tracing::instrument(skip(db))]
-async fn cleanup(
- db: Pool<Postgres>,
- user_id: &str,
- project_ids: &Vec<String>,
- document_ids: &Vec<String>,
-) {
- // Delete project
- for document_id in document_ids {
- if let Err(e) = macro_db_client::document::delete_document(&db, document_id).await {
- tracing::error!(error=?e, document_id=?document_id, "error deleting document from db");
- }
- }
-
- // Go in reverse order so we delete the root last
- for project_id in project_ids {
- if let Err(e) =
- macro_db_client::projects::delete::delete_project(db.clone(), project_id).await
- {
- tracing::error!(error=?e, project_id=?project_id, "error deleting project from db");
- }
- }
-}
diff --git a/services/document_storage_service/src/api/swagger.rs b/services/document_storage_service/src/api/swagger.rs
index f685547f10..a77be9d2fe 100644
--- a/services/document_storage_service/src/api/swagger.rs
+++ b/services/document_storage_service/src/api/swagger.rs
@@ -18,10 +18,6 @@ use crate::{
},
},
entity, health, history, instructions, pins,
- projects::{
- self,
- delete_project::{ProjectDeleteResponse, ProjectDeleteResponseData},
- },
recents::{
self,
recently_deleted::{RecentlyDeletedResponse, RecentlyDeletedResponseData},
@@ -125,6 +121,9 @@ use models_soup::email_thread::{
};
use models_soup::foreign_entity::SoupForeignEntity;
use models_soup::project::SoupProject;
+use projects_hex::inbound::axum_router::delete_project::{
+ ProjectDeleteResponse, ProjectDeleteResponseData,
+};
use soup::domain::models::{SoupItemWithProperties, SoupPropertiesField};
use soup::inbound::axum_router::{
ApiGroupByField, ApiGroupMeta, GroupedSoupGroupPage, GroupedSoupInitialPage, GroupedSoupPage,
@@ -274,20 +273,20 @@ use utoipa::OpenApi;
pins::get_pins::get_pins_handler,
// projects
- projects::get_projects::get_projects_handler,
- projects::get_projects::get_pending_projects_handler,
- projects::get_project::get_project_content_handler,
- projects::create_project::create_project_handler,
- projects::edit_project::edit_project_handler_v2,
- projects::delete_project::delete_project_handler,
- projects::delete_project::permanently_delete_project_handler,
- projects::upload_folder::upload_folder_handler,
- projects::upload_folder::upload_extract_folder_handler,
- projects::project_permission::get_project_permissions_handler,
- projects::project_permission::get_project_access_level_handler,
- projects::get_batch_preview::get_batch_preview_handler,
- projects::get_project::get_project_handler,
- projects::revert_delete_project::handler,
+ projects_hex::inbound::axum_router::get_projects::get_projects_handler,
+ projects_hex::inbound::axum_router::get_projects::get_pending_projects_handler,
+ projects_hex::inbound::axum_router::get_project::get_project_content_handler,
+ projects_hex::inbound::axum_router::create_project::create_project_handler,
+ projects_hex::inbound::axum_router::edit_project::edit_project_handler,
+ projects_hex::inbound::axum_router::delete_project::delete_project_handler,
+ projects_hex::inbound::axum_router::delete_project::permanently_delete_project_handler,
+ projects_hex::inbound::axum_router::upload_folder::upload_folder_handler,
+ projects_hex::inbound::axum_router::upload_folder::upload_extract_folder_handler,
+ projects_hex::inbound::axum_router::project_permission::get_project_permissions_handler,
+ projects_hex::inbound::axum_router::project_permission::get_project_access_level_handler,
+ projects_hex::inbound::axum_router::get_batch_preview::get_batch_preview_handler,
+ projects_hex::inbound::axum_router::get_project::get_project_handler,
+ projects_hex::inbound::axum_router::revert_delete_project::revert_delete_project_handler,
entity::get_entity_permission::handler,
diff --git a/services/document_storage_service/src/main.rs b/services/document_storage_service/src/main.rs
index b2bdd93fb7..d91eed718d 100644
--- a/services/document_storage_service/src/main.rs
+++ b/services/document_storage_service/src/main.rs
@@ -90,6 +90,14 @@ use notification::domain::service::SqsNotificationIngress;
use notification::domain::service::{NotificationReaderService, PlatformArnConfig};
use notification::outbound::queue::SqsQueue;
use opensearch_client::OpensearchClient;
+use projects_hex::{
+ domain::service::ProjectServiceImpl,
+ inbound::axum_router::ProjectRouterState,
+ outbound::{
+ DynamoBulkUploadAdapter, PgProjectRepo, S3ProjectUploadAdapter, ShaCountAdapter,
+ SqsProjectSearchIndexer,
+ },
+};
use properties::{
NotificationServiceImpl, PermissionServiceImpl, PropertiesPgRepo, PropertiesServiceImpl,
};
@@ -414,6 +422,25 @@ async fn main() -> anyhow::Result<()> {
.context("failed to create kafka event publisher")?,
);
+ let project_service = Arc::new(ProjectServiceImpl::new(
+ PgProjectRepo::new(db.clone()),
+ S3ProjectUploadAdapter::new(
+ macro_aws_config::s3_client().await,
+ config.document_storage_bucket.as_ref(),
+ config.docx_document_upload_bucket.as_ref(),
+ config.upload_staging_bucket.as_ref(),
+ ),
+ DynamoBulkUploadAdapter::new(dynamodb_client.clone()),
+ ShaCountAdapter::new(Redis::new(redis_client.clone())),
+ entity_access_management_service.clone(),
+ SqsProjectSearchIndexer::new(Arc::new(sqs_client.clone())),
+ if cfg!(feature = "local") {
+ Some(uuid::uuid!("d50676e2-0a12-4c62-bc07-4b1cb6d8e9bc"))
+ } else {
+ None
+ },
+ ));
+
let document_service = Arc::new(
DocumentServiceImpl::new(
document_repo,
@@ -855,6 +882,11 @@ async fn main() -> anyhow::Result<()> {
frecency_storage,
channel_list_state,
entity_access_service: entity_access_service.clone(),
+ projects_state: ProjectRouterState {
+ service: project_service,
+ access_service: entity_access_service.clone(),
+ authorization_state: authorization_state.clone(),
+ },
documents_state: DocumentRouterState {
service: document_service.clone(),
access_service: entity_access_service.clone(),
diff --git a/tooling/just/rust.just b/tooling/just/rust.just
index eeb1932afe..3648b4bbce 100644
--- a/tooling/just/rust.just
+++ b/tooling/just/rust.just
@@ -94,6 +94,7 @@ setup_test_envs:
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/saved_views/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/channels/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/documents/.env
+ echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/projects/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/foreign_entity/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/stream/.env
echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/macro_project_utils/.env