Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat hexify projects (#4934)
Will Hutchinson5a56b28c4964
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex 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.jsondeleted file mode 100644index 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.jsonsimilarity index 51%rename from .sqlx/query-7671b43028d90ea50536fbcd10ee0c1625c2e66de29cdf080f66832e62e07e76.jsonrename to .sqlx/query-0aed6a0512b8eea223ea779ab439e8d52636ff0a61271cd918f98ef394dfc854.jsonindex 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.jsondeleted file mode 100644index 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.jsonsimilarity index 55%rename from .sqlx/query-6b7094e2eaf150972507f937e120984ee4911e974d0bcc78248c022d44fa20f1.jsonrename to .sqlx/query-0e925bf811ff9dbf234981b7a857a8e9fa3f87355affb3bfb0363b60461864cd.jsonindex 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.jsonsimilarity index 62%rename from .sqlx/query-3d0cc500bd9cee7fe4179b9ebc8176e5b20c478d2e5c4cba230e5fa3f57d38d6.jsonrename to .sqlx/query-0fbead946cc1cb045e55f15e1c41975495a19cfc847196e4835c52afa602082a.jsonindex 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.jsonsimilarity index 63%rename from .sqlx/query-7704391a443f1375ebd231197c4c21c7843eea381e396a3c688b390ced89620a.jsonrename to .sqlx/query-14d04c75c6870eaee31d5ff6f64e4b8593f0bf6d5d6f97944283aead4d0431e2.jsonindex 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.jsonsimilarity index 51%rename from .sqlx/query-a1bf47e0cd99428ebbd99069e9ed4fdcdb3aaeb946ea3e5ca94dc58050ca7d97.jsonrename to .sqlx/query-18873e86f757831adcdb60bb2c4071a06e3d06d4e2049a25f751146a5f010b13.jsonindex 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.jsondeleted file mode 100644index 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonsimilarity index 53%rename from .sqlx/query-7f5d80a93c34a98c84c86f6dd678139fbab4c5bf559090a45d79384bcef71a43.jsonrename to .sqlx/query-3359f22541c580890c7edeb19f8006bb75c8ba82b70fa836241251a497c470fd.jsonindex 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.jsondeleted file mode 100644index 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonsimilarity index 52%rename from .sqlx/query-00b50429eacf802503b639b2dc362bbdbf3d29b375b73ca25f7720941929f10b.jsonrename to .sqlx/query-459f452f7069c7c587f0894fc7dca749b68d522255f51845cde57626dbaa3fa2.jsonindex 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonsimilarity index 61%rename from .sqlx/query-3e3b2b04a9eb28ea82f8f97a2b725b205e0b6f330e4f3eb9690375e992ce2194.jsonrename to .sqlx/query-6313733f77106a1838adbbe6e978b3c1bc4f48dc47815d940471d199e0f5c774.jsonindex 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsondeleted file mode 100644index 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.jsonsimilarity index 67%rename from .sqlx/query-3ff726c2ff64c69e2af5dca67815300efe7b0bcbd74ae96f3d65aeb8edd064f7.jsonrename to .sqlx/query-80fbc24b20f3779fb5fa64c4aae380f6f8aaee7e41069f45d55f60270b792786.jsonindex 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.jsonsimilarity index 60%rename from .sqlx/query-c0b0f58e6b2129250821f51fcb1ebe9d876c2e251f04f0aa9b1c0942d73a4e0d.jsonrename to .sqlx/query-8293d118c38a99fcfbe14d597e38f12d92766a89f8677ac047a8e8c5ea31560b.jsonindex 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonsimilarity index 62%rename from .sqlx/query-4be607458d6cc823fa5a692842b502b405bd0e971be8425d4573846beadb6bf3.jsonrename to .sqlx/query-933dfce0a31e88e5aeefacfbc04301874e36cc9b22b07598ec907cd233b732d8.jsonindex 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.jsonsimilarity index 51%rename from .sqlx/query-0da786be8ae29e36cd110a8875d838e3b6b8cf4bd6775d083867c733982545dd.jsonrename to .sqlx/query-982c8a418e1b883942e3834dab248284e675746317976e608d388a769016428e.jsonindex 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsondeleted file mode 100644index 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.jsonsimilarity index 62%rename from .sqlx/query-fc9cc90bb37368b293d46d43efd16c178a9865c5926e4195249eb22e2a4a91b3.jsonrename to .sqlx/query-aa6fe473019ca57efd0c5404bc92ad841a7a2c354d9fbed3aa60e27e33a3be43.jsonindex 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonsimilarity index 61%rename from .sqlx/query-11a723b710519837eb7643af73af6526dfa6bf93465f9c6708dc95e8237c1f51.jsonrename to .sqlx/query-d5c3283be4274573b38b4a0e87c6b3c82e50546d6b7f570c11a4ee546700853f.jsonindex 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.jsondeleted file mode 100644index 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.jsondeleted file mode 100644index 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.jsonsimilarity index 60%rename from .sqlx/query-980f95d4b95f6a981b86bdbdda30b4b5ee7ee34505f206d0a6861cec41ef589a.jsonrename to .sqlx/query-e6f54d0c4d83082c35620286bb6cb1d064870430b1cfa543cf2532e251205058.jsonindex 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.jsonsimilarity index 63%rename from .sqlx/query-9d8ebf3f5901badeacb46837f0a2222f49274e9e72dbd25cf9c197b4f97654a5.jsonrename to .sqlx/query-ec742212dfe9641ff0120ba4a4870b6938f508d29ac1e5eb71b75717331f54d1.jsonindex 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.jsonnew file mode 100644index 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.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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.lockindex 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.tsindex 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.tsindex 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.tsindex 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.jsonindex 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.rsdeleted file mode 100644index 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.rsindex 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,- ¯o_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.rsdeleted file mode 100644index 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.rsindex 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsindex 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.rsindex 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.rsdeleted file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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,- ¯o_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,- "[email protected]",- "[email protected]",- "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|[email protected]",- "[email protected]",- 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.rsindex 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.rsindex 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.tomlnew file mode 100644index 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.sqlnew file mode 100644index 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/justfilenew file mode 100644index 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-featuresdiff --git a/crates/projects/src/domain.rs b/crates/projects/src/domain.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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",+ "macro|[email protected]",+ 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(),+ "macro|[email protected]",+ 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(),+ "macro|[email protected]",+ 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(),+ "macro|[email protected]",+ 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(),+ "macro|[email protected]",+ 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.tomlindex 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.rsindex 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<MacroAuthJwpub(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.rsindex 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.rsindex 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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(- ¯o_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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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.rsindex 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.rsindex 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.justindex 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/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/channels/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/documents/.env+ echo "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/projects/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/foreign_entity/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/stream/.envecho "DATABASE_URL={{ DATABASE_URL }}" >> ./crates/macro_project_utils/.env