From 9038120734af1213926965aa1d235c238f5042aa Mon Sep 17 00:00:00 2001 From: Rogier Reerink Date: Wed, 7 Oct 2026 22:37:59 +0200 Subject: [PATCH] Added user apps and token resources. --- ...615644f66ad541bbad08d38f4a67c86c57a37.json | 29 +++ ...986014a6f0615c17e9e8a6ecd776924562b99.json | 30 +++ ...47581bbc02bdac145f58d3c97d1d11671f949.json | 23 +++ ...9904cf9c5e71ca6a8dee4ed3ebe7afec9383e.json | 23 +++ ...0fd055e342ba311a12264e34454414cb2325d.json | 26 +++ ...ed22c38da844dbe7044cafc683bbcacb79d7a.json | 21 ++ ...fc8f4625ecc6abde27ae037a6e461e0fe0b6e.json | 48 +++++ ...182a94adf1952a800371e668aeab6897c94c5.json | 14 ++ ...949e895611df56fb0c07a54b2536b6a3a6329.json | 23 +++ ...0d66d01c6083166bd6a6f53784ddcdc92f12c.json | 55 +++++ ...ceead2cf1ff00bd837c0fc42ec81347faa383.json | 47 +++++ ...e92f053d6a36609af5f6a244a2c236e3ffb21.json | 35 ++++ server/Cargo.lock | 1 + server/Cargo.toml | 1 + .../20261007000000_create_user_apps.sql | 4 + ...20261007000001_create_user_app_secrets.sql | 11 + .../20261007000002_create_tokens.sql | 14 ++ ....sql => 20261231000000_seed_demo_data.sql} | 0 server/src/crypto.rs | 44 ++++ server/src/database.rs | 11 + server/src/database/dtos.rs | 6 + server/src/database/dtos/token.rs | 13 ++ server/src/database/dtos/user_app.rs | 6 + server/src/database/dtos/user_app_secret.rs | 10 + server/src/database/tokens.rs | 86 ++++++++ server/src/database/user_app_secrets.rs | 163 +++++++++++++++ server/src/database/user_apps.rs | 129 ++++++++++++ server/src/domain.rs | 6 + server/src/domain/token.rs | 14 ++ server/src/domain/user_app.rs | 7 + server/src/domain/user_app_secret.rs | 11 + server/src/error.rs | 20 ++ server/src/main.rs | 1 + server/src/repository.rs | 9 + server/src/repository/tokens.rs | 56 +++++ server/src/repository/user_app_secrets.rs | 194 ++++++++++++++++++ server/src/repository/user_apps.rs | 172 ++++++++++++++++ server/src/routes.rs | 45 ++-- server/src/routes/auth_token.rs | 127 +++++++++++- server/src/routes/dtos.rs | 3 + server/src/routes/dtos/token.rs | 54 +++++ server/src/routes/dtos/user_app.rs | 53 +++++ server/src/routes/dtos/user_app_secret.rs | 80 ++++++++ server/src/routes/extractors.rs | 1 + server/src/routes/extractors/form.rs | 21 ++ server/src/routes/user_app_secrets.rs | 123 +++++++++++ server/src/routes/user_apps.rs | 99 +++++++++ 47 files changed, 1940 insertions(+), 29 deletions(-) create mode 100644 server/.sqlx/query-1726695ea4d8786d8e489a763cd615644f66ad541bbad08d38f4a67c86c57a37.json create mode 100644 server/.sqlx/query-1eec346cce152ba824c9f49b406986014a6f0615c17e9e8a6ecd776924562b99.json create mode 100644 server/.sqlx/query-28650c14def0b3089a1c6f10d9947581bbc02bdac145f58d3c97d1d11671f949.json create mode 100644 server/.sqlx/query-38166013a2b30661d0666a7b6629904cf9c5e71ca6a8dee4ed3ebe7afec9383e.json create mode 100644 server/.sqlx/query-398a4f8e5438799586f42687d120fd055e342ba311a12264e34454414cb2325d.json create mode 100644 server/.sqlx/query-3fcfa5b534e0ad39d2daecd9654ed22c38da844dbe7044cafc683bbcacb79d7a.json create mode 100644 server/.sqlx/query-8d016626a5df98a049b4d32abe1fc8f4625ecc6abde27ae037a6e461e0fe0b6e.json create mode 100644 server/.sqlx/query-9f8fc6351a1261dcb91eb6f2bfe182a94adf1952a800371e668aeab6897c94c5.json create mode 100644 server/.sqlx/query-a49a3149600f1ad83c82aee5910949e895611df56fb0c07a54b2536b6a3a6329.json create mode 100644 server/.sqlx/query-b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c.json create mode 100644 server/.sqlx/query-b7d48fe3fd0300c94344d7d8e93ceead2cf1ff00bd837c0fc42ec81347faa383.json create mode 100644 server/.sqlx/query-e4cc5672787e94ee849cb175416e92f053d6a36609af5f6a244a2c236e3ffb21.json create mode 100644 server/migrations/20261007000000_create_user_apps.sql create mode 100644 server/migrations/20261007000001_create_user_app_secrets.sql create mode 100644 server/migrations/20261007000002_create_tokens.sql rename server/migrations/{20260928000000_seed_demo_data.sql => 20261231000000_seed_demo_data.sql} (100%) create mode 100644 server/src/crypto.rs create mode 100644 server/src/database/dtos/token.rs create mode 100644 server/src/database/dtos/user_app.rs create mode 100644 server/src/database/dtos/user_app_secret.rs create mode 100644 server/src/database/tokens.rs create mode 100644 server/src/database/user_app_secrets.rs create mode 100644 server/src/database/user_apps.rs create mode 100644 server/src/domain/token.rs create mode 100644 server/src/domain/user_app.rs create mode 100644 server/src/domain/user_app_secret.rs create mode 100644 server/src/repository/tokens.rs create mode 100644 server/src/repository/user_app_secrets.rs create mode 100644 server/src/repository/user_apps.rs create mode 100644 server/src/routes/dtos/token.rs create mode 100644 server/src/routes/dtos/user_app.rs create mode 100644 server/src/routes/dtos/user_app_secret.rs create mode 100644 server/src/routes/extractors/form.rs create mode 100644 server/src/routes/user_app_secrets.rs create mode 100644 server/src/routes/user_apps.rs diff --git a/server/.sqlx/query-1726695ea4d8786d8e489a763cd615644f66ad541bbad08d38f4a67c86c57a37.json b/server/.sqlx/query-1726695ea4d8786d8e489a763cd615644f66ad541bbad08d38f4a67c86c57a37.json new file mode 100644 index 0000000..ad2aa04 --- /dev/null +++ b/server/.sqlx/query-1726695ea4d8786d8e489a763cd615644f66ad541bbad08d38f4a67c86c57a37.json @@ -0,0 +1,29 @@ +{ + "db_name": "PostgreSQL", + "query": "\n SELECT id, user_id\n FROM user_apps\n WHERE user_id = $1 AND id = $2\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "user_id", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Uuid" + ] + }, + "nullable": [ + false, + false + ] + }, + "hash": "1726695ea4d8786d8e489a763cd615644f66ad541bbad08d38f4a67c86c57a37" +} diff --git a/server/.sqlx/query-1eec346cce152ba824c9f49b406986014a6f0615c17e9e8a6ecd776924562b99.json b/server/.sqlx/query-1eec346cce152ba824c9f49b406986014a6f0615c17e9e8a6ecd776924562b99.json new file mode 100644 index 0000000..01ed61d --- /dev/null +++ b/server/.sqlx/query-1eec346cce152ba824c9f49b406986014a6f0615c17e9e8a6ecd776924562b99.json @@ -0,0 +1,30 @@ +{ + "db_name": "PostgreSQL", + "query": "\n SELECT id, user_id\n FROM user_apps\n WHERE user_id = $1\n ORDER BY id\n LIMIT $2\n OFFSET $3\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "user_id", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Int8", + "Int8" + ] + }, + "nullable": [ + false, + false + ] + }, + "hash": "1eec346cce152ba824c9f49b406986014a6f0615c17e9e8a6ecd776924562b99" +} diff --git a/server/.sqlx/query-28650c14def0b3089a1c6f10d9947581bbc02bdac145f58d3c97d1d11671f949.json b/server/.sqlx/query-28650c14def0b3089a1c6f10d9947581bbc02bdac145f58d3c97d1d11671f949.json new file mode 100644 index 0000000..dabe500 --- /dev/null +++ b/server/.sqlx/query-28650c14def0b3089a1c6f10d9947581bbc02bdac145f58d3c97d1d11671f949.json @@ -0,0 +1,23 @@ +{ + "db_name": "PostgreSQL", + "query": "DELETE FROM user_app_secrets WHERE app_id = $1 AND id = $2 RETURNING id", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Uuid" + ] + }, + "nullable": [ + false + ] + }, + "hash": "28650c14def0b3089a1c6f10d9947581bbc02bdac145f58d3c97d1d11671f949" +} diff --git a/server/.sqlx/query-38166013a2b30661d0666a7b6629904cf9c5e71ca6a8dee4ed3ebe7afec9383e.json b/server/.sqlx/query-38166013a2b30661d0666a7b6629904cf9c5e71ca6a8dee4ed3ebe7afec9383e.json new file mode 100644 index 0000000..f2226d9 --- /dev/null +++ b/server/.sqlx/query-38166013a2b30661d0666a7b6629904cf9c5e71ca6a8dee4ed3ebe7afec9383e.json @@ -0,0 +1,23 @@ +{ + "db_name": "PostgreSQL", + "query": "DELETE FROM user_apps WHERE user_id = $1 AND id = $2 RETURNING id", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Uuid" + ] + }, + "nullable": [ + false + ] + }, + "hash": "38166013a2b30661d0666a7b6629904cf9c5e71ca6a8dee4ed3ebe7afec9383e" +} diff --git a/server/.sqlx/query-398a4f8e5438799586f42687d120fd055e342ba311a12264e34454414cb2325d.json b/server/.sqlx/query-398a4f8e5438799586f42687d120fd055e342ba311a12264e34454414cb2325d.json new file mode 100644 index 0000000..2c34c4c --- /dev/null +++ b/server/.sqlx/query-398a4f8e5438799586f42687d120fd055e342ba311a12264e34454414cb2325d.json @@ -0,0 +1,26 @@ +{ + "db_name": "PostgreSQL", + "query": "\n UPDATE tokens\n SET access_token_hash = $2,\n refresh_token_hash = $3,\n access_expires_at = $4,\n refresh_expires_at = $5\n WHERE refresh_token_hash = $1\n AND revoked_at IS NULL\n AND refresh_expires_at > now()\n RETURNING id\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Bytea", + "Bytea", + "Bytea", + "Timestamptz", + "Timestamptz" + ] + }, + "nullable": [ + false + ] + }, + "hash": "398a4f8e5438799586f42687d120fd055e342ba311a12264e34454414cb2325d" +} diff --git a/server/.sqlx/query-3fcfa5b534e0ad39d2daecd9654ed22c38da844dbe7044cafc683bbcacb79d7a.json b/server/.sqlx/query-3fcfa5b534e0ad39d2daecd9654ed22c38da844dbe7044cafc683bbcacb79d7a.json new file mode 100644 index 0000000..6317db8 --- /dev/null +++ b/server/.sqlx/query-3fcfa5b534e0ad39d2daecd9654ed22c38da844dbe7044cafc683bbcacb79d7a.json @@ -0,0 +1,21 @@ +{ + "db_name": "PostgreSQL", + "query": "\n INSERT INTO tokens (\n id, app_id, access_token_hash, refresh_token_hash,\n access_expires_at, refresh_expires_at, revoked_at, created_at\n )\n VALUES ($1, $2, $3, $4, $5, $6, $7, $8)\n ", + "describe": { + "columns": [], + "parameters": { + "Left": [ + "Uuid", + "Uuid", + "Bytea", + "Bytea", + "Timestamptz", + "Timestamptz", + "Timestamptz", + "Timestamptz" + ] + }, + "nullable": [] + }, + "hash": "3fcfa5b534e0ad39d2daecd9654ed22c38da844dbe7044cafc683bbcacb79d7a" +} diff --git a/server/.sqlx/query-8d016626a5df98a049b4d32abe1fc8f4625ecc6abde27ae037a6e461e0fe0b6e.json b/server/.sqlx/query-8d016626a5df98a049b4d32abe1fc8f4625ecc6abde27ae037a6e461e0fe0b6e.json new file mode 100644 index 0000000..0316e23 --- /dev/null +++ b/server/.sqlx/query-8d016626a5df98a049b4d32abe1fc8f4625ecc6abde27ae037a6e461e0fe0b6e.json @@ -0,0 +1,48 @@ +{ + "db_name": "PostgreSQL", + "query": "\n SELECT id, app_id, secret_hash, expires_at, created_at\n FROM user_app_secrets\n WHERE app_id = $1\n ORDER BY created_at DESC, id DESC\n LIMIT $2\n OFFSET $3\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "app_id", + "type_info": "Uuid" + }, + { + "ordinal": 2, + "name": "secret_hash", + "type_info": "Bytea" + }, + { + "ordinal": 3, + "name": "expires_at", + "type_info": "Timestamptz" + }, + { + "ordinal": 4, + "name": "created_at", + "type_info": "Timestamptz" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Int8", + "Int8" + ] + }, + "nullable": [ + false, + false, + false, + false, + false + ] + }, + "hash": "8d016626a5df98a049b4d32abe1fc8f4625ecc6abde27ae037a6e461e0fe0b6e" +} diff --git a/server/.sqlx/query-9f8fc6351a1261dcb91eb6f2bfe182a94adf1952a800371e668aeab6897c94c5.json b/server/.sqlx/query-9f8fc6351a1261dcb91eb6f2bfe182a94adf1952a800371e668aeab6897c94c5.json new file mode 100644 index 0000000..dbec2c0 --- /dev/null +++ b/server/.sqlx/query-9f8fc6351a1261dcb91eb6f2bfe182a94adf1952a800371e668aeab6897c94c5.json @@ -0,0 +1,14 @@ +{ + "db_name": "PostgreSQL", + "query": "\n UPDATE tokens\n SET revoked_at = COALESCE(revoked_at, now())\n WHERE access_token_hash = $1 OR refresh_token_hash = $1\n ", + "describe": { + "columns": [], + "parameters": { + "Left": [ + "Bytea" + ] + }, + "nullable": [] + }, + "hash": "9f8fc6351a1261dcb91eb6f2bfe182a94adf1952a800371e668aeab6897c94c5" +} diff --git a/server/.sqlx/query-a49a3149600f1ad83c82aee5910949e895611df56fb0c07a54b2536b6a3a6329.json b/server/.sqlx/query-a49a3149600f1ad83c82aee5910949e895611df56fb0c07a54b2536b6a3a6329.json new file mode 100644 index 0000000..fe8479e --- /dev/null +++ b/server/.sqlx/query-a49a3149600f1ad83c82aee5910949e895611df56fb0c07a54b2536b6a3a6329.json @@ -0,0 +1,23 @@ +{ + "db_name": "PostgreSQL", + "query": "\n SELECT EXISTS (\n SELECT 1\n FROM user_app_secrets\n WHERE app_id = $1 AND secret_hash = $2 AND expires_at > now()\n ) AS \"is_valid!\"\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "is_valid!", + "type_info": "Bool" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Bytea" + ] + }, + "nullable": [ + null + ] + }, + "hash": "a49a3149600f1ad83c82aee5910949e895611df56fb0c07a54b2536b6a3a6329" +} diff --git a/server/.sqlx/query-b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c.json b/server/.sqlx/query-b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c.json new file mode 100644 index 0000000..04ec1cf --- /dev/null +++ b/server/.sqlx/query-b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c.json @@ -0,0 +1,55 @@ +{ + "db_name": "PostgreSQL", + "query": "\n INSERT INTO user_app_secrets (id, app_id, secret_hash, expires_at)\n VALUES ($1, $2, $3, $4)\n ON CONFLICT (id) DO UPDATE SET\n secret_hash = EXCLUDED.secret_hash,\n expires_at = EXCLUDED.expires_at\n WHERE user_app_secrets.app_id = EXCLUDED.app_id\n RETURNING WITH (OLD AS old_row, NEW AS new_row)\n old_row.id AS \"old_id?\",\n new_row.id AS \"id!\",\n new_row.app_id AS \"app_id!\",\n new_row.secret_hash AS \"secret_hash!\",\n new_row.expires_at AS \"expires_at!\",\n new_row.created_at AS \"created_at!\"\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "old_id?", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "id!", + "type_info": "Uuid" + }, + { + "ordinal": 2, + "name": "app_id!", + "type_info": "Uuid" + }, + { + "ordinal": 3, + "name": "secret_hash!", + "type_info": "Bytea" + }, + { + "ordinal": 4, + "name": "expires_at!", + "type_info": "Timestamptz" + }, + { + "ordinal": 5, + "name": "created_at!", + "type_info": "Timestamptz" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Uuid", + "Bytea", + "Timestamptz" + ] + }, + "nullable": [ + false, + false, + false, + false, + false, + false + ] + }, + "hash": "b01b27f9cdf2ec1c9aa28be0e760d66d01c6083166bd6a6f53784ddcdc92f12c" +} diff --git a/server/.sqlx/query-b7d48fe3fd0300c94344d7d8e93ceead2cf1ff00bd837c0fc42ec81347faa383.json b/server/.sqlx/query-b7d48fe3fd0300c94344d7d8e93ceead2cf1ff00bd837c0fc42ec81347faa383.json new file mode 100644 index 0000000..5ae4be4 --- /dev/null +++ b/server/.sqlx/query-b7d48fe3fd0300c94344d7d8e93ceead2cf1ff00bd837c0fc42ec81347faa383.json @@ -0,0 +1,47 @@ +{ + "db_name": "PostgreSQL", + "query": "\n SELECT id, app_id, secret_hash, expires_at, created_at\n FROM user_app_secrets\n WHERE app_id = $1 AND id = $2\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "app_id", + "type_info": "Uuid" + }, + { + "ordinal": 2, + "name": "secret_hash", + "type_info": "Bytea" + }, + { + "ordinal": 3, + "name": "expires_at", + "type_info": "Timestamptz" + }, + { + "ordinal": 4, + "name": "created_at", + "type_info": "Timestamptz" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Uuid" + ] + }, + "nullable": [ + false, + false, + false, + false, + false + ] + }, + "hash": "b7d48fe3fd0300c94344d7d8e93ceead2cf1ff00bd837c0fc42ec81347faa383" +} diff --git a/server/.sqlx/query-e4cc5672787e94ee849cb175416e92f053d6a36609af5f6a244a2c236e3ffb21.json b/server/.sqlx/query-e4cc5672787e94ee849cb175416e92f053d6a36609af5f6a244a2c236e3ffb21.json new file mode 100644 index 0000000..dc30807 --- /dev/null +++ b/server/.sqlx/query-e4cc5672787e94ee849cb175416e92f053d6a36609af5f6a244a2c236e3ffb21.json @@ -0,0 +1,35 @@ +{ + "db_name": "PostgreSQL", + "query": "\n INSERT INTO user_apps (id, user_id)\n VALUES ($1, $2)\n ON CONFLICT (id) DO UPDATE SET\n id = EXCLUDED.id\n RETURNING WITH (OLD AS old_row, NEW AS new_row)\n old_row.id AS \"old_id?\",\n new_row.id AS \"id!\",\n new_row.user_id AS \"user_id!\"\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "old_id?", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "id!", + "type_info": "Uuid" + }, + { + "ordinal": 2, + "name": "user_id!", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Uuid" + ] + }, + "nullable": [ + false, + false, + false + ] + }, + "hash": "e4cc5672787e94ee849cb175416e92f053d6a36609af5f6a244a2c236e3ffb21" +} diff --git a/server/Cargo.lock b/server/Cargo.lock index 74b0ff2..5a03455 100644 --- a/server/Cargo.lock +++ b/server/Cargo.lock @@ -1305,6 +1305,7 @@ dependencies = [ "axum", "chrono", "dotenv", + "ring", "serde", "serde_json", "sqlx", diff --git a/server/Cargo.toml b/server/Cargo.toml index eb623fd..859a8e9 100644 --- a/server/Cargo.toml +++ b/server/Cargo.toml @@ -10,6 +10,7 @@ chrono = { version = "0.4.45", features = ["serde"] } dotenv = "0.15.0" serde = { version = "1.0.229", features = ["derive"] } serde_json = "1.0.151" +ring = "0.17.14" sqlx = { version = "0.8.6", default-features = false, features = [ "runtime-tokio-rustls", "postgres", diff --git a/server/migrations/20261007000000_create_user_apps.sql b/server/migrations/20261007000000_create_user_apps.sql new file mode 100644 index 0000000..6a57fc7 --- /dev/null +++ b/server/migrations/20261007000000_create_user_apps.sql @@ -0,0 +1,4 @@ +CREATE TABLE user_apps ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid (), + user_id UUID NOT NULL CONSTRAINT fk_user_apps_user REFERENCES users (id) ON DELETE CASCADE +); \ No newline at end of file diff --git a/server/migrations/20261007000001_create_user_app_secrets.sql b/server/migrations/20261007000001_create_user_app_secrets.sql new file mode 100644 index 0000000..c910c95 --- /dev/null +++ b/server/migrations/20261007000001_create_user_app_secrets.sql @@ -0,0 +1,11 @@ +CREATE TABLE user_app_secrets ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid (), + app_id UUID NOT NULL CONSTRAINT fk_user_app_secrets_app REFERENCES user_apps (id) ON DELETE CASCADE, + secret_hash BYTEA NOT NULL CHECK ( + octet_length(secret_hash) = 32 + ), + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX ix_user_app_secrets_app_id ON user_app_secrets (app_id); \ No newline at end of file diff --git a/server/migrations/20261007000002_create_tokens.sql b/server/migrations/20261007000002_create_tokens.sql new file mode 100644 index 0000000..08824de --- /dev/null +++ b/server/migrations/20261007000002_create_tokens.sql @@ -0,0 +1,14 @@ +CREATE TABLE tokens ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid (), + app_id UUID NOT NULL CONSTRAINT fk_tokens_app REFERENCES user_apps (id) ON DELETE CASCADE, + access_token_hash BYTEA NOT NULL UNIQUE CHECK ( + octet_length(access_token_hash) = 32 + ), + refresh_token_hash BYTEA NOT NULL UNIQUE CHECK ( + octet_length(refresh_token_hash) = 32 + ), + access_expires_at TIMESTAMPTZ NOT NULL, + refresh_expires_at TIMESTAMPTZ NOT NULL, + revoked_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); \ No newline at end of file diff --git a/server/migrations/20260928000000_seed_demo_data.sql b/server/migrations/20261231000000_seed_demo_data.sql similarity index 100% rename from server/migrations/20260928000000_seed_demo_data.sql rename to server/migrations/20261231000000_seed_demo_data.sql diff --git a/server/src/crypto.rs b/server/src/crypto.rs new file mode 100644 index 0000000..889621b --- /dev/null +++ b/server/src/crypto.rs @@ -0,0 +1,44 @@ +use ring::{ + digest, + rand::{SecureRandom, SystemRandom}, +}; + +pub fn generate_secret() -> Result { + let mut bytes = [0; 32]; + SystemRandom::new().fill(&mut bytes)?; + + let mut secret = String::with_capacity(bytes.len() * 2); + for byte in bytes { + use std::fmt::Write; + write!(&mut secret, "{byte:02x}").expect("writing to a String cannot fail"); + } + + Ok(secret) +} + +pub fn hash_secret(secret: &str) -> Vec { + digest::digest(&digest::SHA256, secret.as_bytes()) + .as_ref() + .to_vec() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn generates_256_bit_hex_secrets() { + let first = generate_secret().unwrap(); + let second = generate_secret().unwrap(); + + assert_eq!(first.len(), 64); + assert!(first.bytes().all(|byte| byte.is_ascii_hexdigit())); + assert_ne!(first, second); + } + + #[test] + fn hashes_secrets_deterministically() { + assert_eq!(hash_secret("test-secret"), hash_secret("test-secret")); + assert_ne!(hash_secret("test-secret"), hash_secret("other-secret")); + } +} diff --git a/server/src/database.rs b/server/src/database.rs index 8f13ec1..4b3d094 100644 --- a/server/src/database.rs +++ b/server/src/database.rs @@ -2,7 +2,10 @@ pub mod accounts; pub mod dtos; mod error_codes; pub mod recurring_transactions; +pub mod tokens; pub mod transactions; +pub mod user_app_secrets; +pub mod user_apps; pub mod users; use error_codes::PG_FOREIGN_KEY_VIOLATION; @@ -43,6 +46,12 @@ impl From for DatabaseError { #[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] pub enum Constraint { + #[error("user app user constraint")] + UserAppUser, + + #[error("user app secret app constraint")] + UserAppSecretApp, + #[error("transaction account constraint")] TransactionAccount, @@ -59,6 +68,8 @@ pub enum Constraint { impl From<&str> for Constraint { fn from(constraint: &str) -> Self { match constraint { + "fk_user_apps_user" => Constraint::UserAppUser, + "fk_user_app_secrets_app" => Constraint::UserAppSecretApp, "fk_transactions_account" => Constraint::TransactionAccount, "fk_recurring_transactions_account" => Constraint::RecurringTransactionAccount, _ => Constraint::Unknown(constraint.to_string()), diff --git a/server/src/database/dtos.rs b/server/src/database/dtos.rs index c8f61d8..5fdf78a 100644 --- a/server/src/database/dtos.rs +++ b/server/src/database/dtos.rs @@ -1,11 +1,17 @@ mod account; mod recurring_transaction; mod results; +mod token; mod transaction; mod user; +mod user_app; +mod user_app_secret; pub use account::*; pub use recurring_transaction::*; pub use results::*; +pub use token::*; pub use transaction::*; pub use user::*; +pub use user_app::*; +pub use user_app_secret::*; diff --git a/server/src/database/dtos/token.rs b/server/src/database/dtos/token.rs new file mode 100644 index 0000000..96ac13a --- /dev/null +++ b/server/src/database/dtos/token.rs @@ -0,0 +1,13 @@ +use chrono::{DateTime, Utc}; +use uuid::Uuid; + +pub struct TokenRow { + pub id: Uuid, + pub app_id: Uuid, + pub access_token_hash: Vec, + pub refresh_token_hash: Vec, + pub access_expires_at: DateTime, + pub refresh_expires_at: DateTime, + pub revoked_at: Option>, + pub created_at: DateTime, +} diff --git a/server/src/database/dtos/user_app.rs b/server/src/database/dtos/user_app.rs new file mode 100644 index 0000000..dad69bf --- /dev/null +++ b/server/src/database/dtos/user_app.rs @@ -0,0 +1,6 @@ +use uuid::Uuid; + +pub struct UserAppRow { + pub id: Uuid, + pub user_id: Uuid, +} diff --git a/server/src/database/dtos/user_app_secret.rs b/server/src/database/dtos/user_app_secret.rs new file mode 100644 index 0000000..fed781e --- /dev/null +++ b/server/src/database/dtos/user_app_secret.rs @@ -0,0 +1,10 @@ +use chrono::{DateTime, Utc}; +use uuid::Uuid; + +pub struct UserAppSecretRow { + pub id: Uuid, + pub app_id: Uuid, + pub secret_hash: Vec, + pub expires_at: DateTime, + pub created_at: DateTime, +} diff --git a/server/src/database/tokens.rs b/server/src/database/tokens.rs new file mode 100644 index 0000000..8f20500 --- /dev/null +++ b/server/src/database/tokens.rs @@ -0,0 +1,86 @@ +use chrono::{DateTime, Utc}; + +use super::{DatabaseError, dtos::TokenRow}; + +pub async fn issue<'e, E>(executor: E, token: TokenRow) -> Result<(), DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query!( + r#" + INSERT INTO tokens ( + id, app_id, access_token_hash, refresh_token_hash, + access_expires_at, refresh_expires_at, revoked_at, created_at + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8) + "#, + token.id, + token.app_id, + token.access_token_hash, + token.refresh_token_hash, + token.access_expires_at, + token.refresh_expires_at, + token.revoked_at, + token.created_at, + ) + .execute(executor) + .await + .map_err(DatabaseError::from)?; + + Ok(()) +} + +pub async fn rotate_refresh_token<'e, E>( + executor: E, + old_refresh_hash: &[u8], + access_token_hash: &[u8], + refresh_token_hash: &[u8], + access_expires_at: DateTime, + refresh_expires_at: DateTime, +) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let row = sqlx::query!( + r#" + UPDATE tokens + SET access_token_hash = $2, + refresh_token_hash = $3, + access_expires_at = $4, + refresh_expires_at = $5 + WHERE refresh_token_hash = $1 + AND revoked_at IS NULL + AND refresh_expires_at > now() + RETURNING id + "#, + old_refresh_hash, + access_token_hash, + refresh_token_hash, + access_expires_at, + refresh_expires_at, + ) + .fetch_optional(executor) + .await + .map_err(DatabaseError::from)?; + + Ok(row.is_some()) +} + +pub async fn revoke<'e, E>(executor: E, token_hash: &[u8]) -> Result<(), DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query!( + r#" + UPDATE tokens + SET revoked_at = COALESCE(revoked_at, now()) + WHERE access_token_hash = $1 OR refresh_token_hash = $1 + "#, + token_hash, + ) + .execute(executor) + .await + .map_err(DatabaseError::from)?; + + Ok(()) +} diff --git a/server/src/database/user_app_secrets.rs b/server/src/database/user_app_secrets.rs new file mode 100644 index 0000000..099031b --- /dev/null +++ b/server/src/database/user_app_secrets.rs @@ -0,0 +1,163 @@ +use uuid::Uuid; + +use super::{ + DatabaseError, + dtos::{Delete, Upsert, UserAppSecretRow}, +}; + +pub struct Query { + pub app_id: Uuid, + pub limit: Option, + pub offset: Option, +} + +impl Default for Query { + fn default() -> Self { + Self { + app_id: Uuid::nil(), + limit: None, + offset: None, + } + } +} + +pub async fn query<'e, E>(executor: E, query: Query) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_as!( + UserAppSecretRow, + r#" + SELECT id, app_id, secret_hash, expires_at, created_at + FROM user_app_secrets + WHERE app_id = $1 + ORDER BY created_at DESC, id DESC + LIMIT $2 + OFFSET $3 + "#, + query.app_id, + query.limit, + query.offset, + ) + .fetch_all(executor) + .await + .map_err(DatabaseError::from) +} + +pub async fn get_by_id<'e, E>( + executor: E, + app_id: Uuid, + id: Uuid, +) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_as!( + UserAppSecretRow, + r#" + SELECT id, app_id, secret_hash, expires_at, created_at + FROM user_app_secrets + WHERE app_id = $1 AND id = $2 + "#, + app_id, + id, + ) + .fetch_optional(executor) + .await + .map_err(DatabaseError::from) +} + +pub async fn upsert<'e, E>( + executor: E, + secret: UserAppSecretRow, +) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let row = sqlx::query!( + r#" + INSERT INTO user_app_secrets (id, app_id, secret_hash, expires_at) + VALUES ($1, $2, $3, $4) + ON CONFLICT (id) DO UPDATE SET + secret_hash = EXCLUDED.secret_hash, + expires_at = EXCLUDED.expires_at + WHERE user_app_secrets.app_id = EXCLUDED.app_id + RETURNING WITH (OLD AS old_row, NEW AS new_row) + old_row.id AS "old_id?", + new_row.id AS "id!", + new_row.app_id AS "app_id!", + new_row.secret_hash AS "secret_hash!", + new_row.expires_at AS "expires_at!", + new_row.created_at AS "created_at!" + "#, + secret.id, + secret.app_id, + secret.secret_hash, + secret.expires_at, + ) + .fetch_one(executor) + .await + .map_err(DatabaseError::from)?; + + let secret = UserAppSecretRow { + id: row.id, + app_id: row.app_id, + secret_hash: row.secret_hash, + expires_at: row.expires_at, + created_at: row.created_at, + }; + + Ok(if row.old_id.is_some() { + Upsert::Updated(secret) + } else { + Upsert::Created(secret) + }) +} + +pub async fn verify<'e, E>( + executor: E, + app_id: Uuid, + secret_hash: &[u8], +) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_scalar!( + r#" + SELECT EXISTS ( + SELECT 1 + FROM user_app_secrets + WHERE app_id = $1 AND secret_hash = $2 AND expires_at > now() + ) AS "is_valid!" + "#, + app_id, + secret_hash, + ) + .fetch_one(executor) + .await + .map_err(DatabaseError::from) +} + +pub async fn delete_by_id<'e, E>( + executor: E, + app_id: Uuid, + id: Uuid, +) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let deleted = sqlx::query!( + "DELETE FROM user_app_secrets WHERE app_id = $1 AND id = $2 RETURNING id", + app_id, + id, + ) + .fetch_optional(executor) + .await + .map_err(DatabaseError::from)?; + + Ok(if deleted.is_some() { + Delete::Deleted + } else { + Delete::NotFound + }) +} diff --git a/server/src/database/user_apps.rs b/server/src/database/user_apps.rs new file mode 100644 index 0000000..d0892b0 --- /dev/null +++ b/server/src/database/user_apps.rs @@ -0,0 +1,129 @@ +use uuid::Uuid; + +use super::{ + DatabaseError, + dtos::{Delete, Upsert, UserAppRow}, +}; + +pub struct Query { + pub user_id: Uuid, + pub limit: Option, + pub offset: Option, +} + +impl Default for Query { + fn default() -> Self { + Self { + user_id: Uuid::nil(), + limit: None, + offset: None, + } + } +} + +pub async fn query<'e, E>(executor: E, query: Query) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_as!( + UserAppRow, + r#" + SELECT id, user_id + FROM user_apps + WHERE user_id = $1 + ORDER BY id + LIMIT $2 + OFFSET $3 + "#, + query.user_id, + query.limit, + query.offset, + ) + .fetch_all(executor) + .await + .map_err(DatabaseError::from) +} + +pub async fn get_by_id<'e, E>( + executor: E, + user_id: Uuid, + id: Uuid, +) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_as!( + UserAppRow, + r#" + SELECT id, user_id + FROM user_apps + WHERE user_id = $1 AND id = $2 + "#, + user_id, + id, + ) + .fetch_optional(executor) + .await + .map_err(DatabaseError::from) +} + +pub async fn upsert<'e, E>( + executor: E, + app: UserAppRow, +) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let row = sqlx::query!( + r#" + INSERT INTO user_apps (id, user_id) + VALUES ($1, $2) + ON CONFLICT (id) DO UPDATE SET + id = EXCLUDED.id + RETURNING WITH (OLD AS old_row, NEW AS new_row) + old_row.id AS "old_id?", + new_row.id AS "id!", + new_row.user_id AS "user_id!" + "#, + app.id, + app.user_id, + ) + .fetch_one(executor) + .await + .map_err(DatabaseError::from)?; + + let app = UserAppRow { + id: row.id, + user_id: row.user_id, + }; + + Ok(if row.old_id.is_some() { + Upsert::Updated(app) + } else { + Upsert::Created(app) + }) +} + +pub async fn delete_by_id<'e, E>( + executor: E, + user_id: Uuid, + id: Uuid, +) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let deleted = sqlx::query!( + "DELETE FROM user_apps WHERE user_id = $1 AND id = $2 RETURNING id", + user_id, + id, + ) + .fetch_optional(executor) + .await + .map_err(DatabaseError::from)?; + + Ok(if deleted.is_some() { + Delete::Deleted + } else { + Delete::NotFound + }) +} diff --git a/server/src/domain.rs b/server/src/domain.rs index af301bb..eaa25e9 100644 --- a/server/src/domain.rs +++ b/server/src/domain.rs @@ -3,16 +3,22 @@ mod cents; mod direction; mod recurring_transaction; mod schedule; +mod token; mod transaction; mod user; +mod user_app; +mod user_app_secret; pub use account::*; pub use cents::*; pub use direction::*; pub use recurring_transaction::*; pub use schedule::*; +pub use token::*; pub use transaction::*; pub use user::*; +pub use user_app::*; +pub use user_app_secret::*; #[derive(Debug, thiserror::Error)] pub enum DomainError { diff --git a/server/src/domain/token.rs b/server/src/domain/token.rs new file mode 100644 index 0000000..58581ea --- /dev/null +++ b/server/src/domain/token.rs @@ -0,0 +1,14 @@ +use chrono::{DateTime, Utc}; +use uuid::Uuid; + +#[derive(Clone, PartialEq, Eq)] +pub struct Token { + pub id: Uuid, + pub app_id: Uuid, + pub access_token_hash: Vec, + pub refresh_token_hash: Vec, + pub access_expires_at: DateTime, + pub refresh_expires_at: DateTime, + pub revoked_at: Option>, + pub created_at: DateTime, +} diff --git a/server/src/domain/user_app.rs b/server/src/domain/user_app.rs new file mode 100644 index 0000000..a95108a --- /dev/null +++ b/server/src/domain/user_app.rs @@ -0,0 +1,7 @@ +use uuid::Uuid; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct UserApp { + pub id: Uuid, + pub user_id: Uuid, +} diff --git a/server/src/domain/user_app_secret.rs b/server/src/domain/user_app_secret.rs new file mode 100644 index 0000000..3e89f36 --- /dev/null +++ b/server/src/domain/user_app_secret.rs @@ -0,0 +1,11 @@ +use chrono::{DateTime, Utc}; +use uuid::Uuid; + +#[derive(Clone, PartialEq, Eq)] +pub struct UserAppSecret { + pub id: Uuid, + pub app_id: Uuid, + pub secret_hash: Vec, + pub expires_at: DateTime, + pub created_at: DateTime, +} diff --git a/server/src/error.rs b/server/src/error.rs index 90a676f..4340f82 100644 --- a/server/src/error.rs +++ b/server/src/error.rs @@ -16,6 +16,9 @@ pub enum AppError { #[error("not found")] NotFound, + #[error("unauthorized")] + Unauthorized, + #[error("domain error")] Domain(#[from] DomainError), @@ -35,6 +38,9 @@ impl IntoResponse for AppError { Self::NotFound => { return error_response(StatusCode::NOT_FOUND, "Not found"); } + Self::Unauthorized => { + return error_response(StatusCode::UNAUTHORIZED, "Unauthorized"); + } Self::Domain(error) => { return error_response(StatusCode::UNPROCESSABLE_ENTITY, error.to_string()); } @@ -44,6 +50,20 @@ impl IntoResponse for AppError { Self::Repository(RepositoryError::Decode(error)) => { tracing::error!(%error, "invalid stored data"); } + Self::Repository(RepositoryError::ReferenceViolation { + relation: ReferenceRelation::User, + kind: ReferenceViolationKind::Missing, + .. + }) => { + return error_response(StatusCode::NOT_FOUND, "User cannot be found"); + } + Self::Repository(RepositoryError::ReferenceViolation { + relation: ReferenceRelation::UserApp, + kind: ReferenceViolationKind::Missing, + .. + }) => { + return error_response(StatusCode::NOT_FOUND, "User app cannot be found"); + } Self::Repository(RepositoryError::ReferenceViolation { relation: ReferenceRelation::Account, kind: ReferenceViolationKind::Missing, diff --git a/server/src/main.rs b/server/src/main.rs index 10819de..acd7036 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -4,6 +4,7 @@ use anyhow::Context; use sqlx::postgres::PgPoolOptions; use tokio::net::TcpListener; +mod crypto; mod database; mod domain; mod error; diff --git a/server/src/repository.rs b/server/src/repository.rs index b01d4e2..7631fc1 100644 --- a/server/src/repository.rs +++ b/server/src/repository.rs @@ -7,7 +7,10 @@ pub mod accounts; pub mod dtos; mod encoding; pub mod recurring_transactions; +pub mod tokens; pub mod transactions; +pub mod user_app_secrets; +pub mod user_apps; pub mod users; #[derive(Debug, thiserror::Error)] @@ -62,6 +65,12 @@ pub enum ReferenceRelation { #[error("transaction")] Transaction, + #[error("user")] + User, + + #[error("user app")] + UserApp, + #[error("recurring transaction")] RecurringTransaction, } diff --git a/server/src/repository/tokens.rs b/server/src/repository/tokens.rs new file mode 100644 index 0000000..965f49c --- /dev/null +++ b/server/src/repository/tokens.rs @@ -0,0 +1,56 @@ +use chrono::{DateTime, Utc}; + +use super::RepositoryError; +use crate::{ + database::{dtos::TokenRow, tokens as db}, + domain::Token, +}; + +pub async fn issue<'e, E>(executor: E, token: Token) -> Result<(), RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::issue(executor, encode(token)).await?) +} + +pub async fn rotate_refresh_token<'e, E>( + executor: E, + old_refresh_hash: &[u8], + access_token_hash: &[u8], + refresh_token_hash: &[u8], + access_expires_at: DateTime, + refresh_expires_at: DateTime, +) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::rotate_refresh_token( + executor, + old_refresh_hash, + access_token_hash, + refresh_token_hash, + access_expires_at, + refresh_expires_at, + ) + .await?) +} + +pub async fn revoke<'e, E>(executor: E, token_hash: &[u8]) -> Result<(), RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::revoke(executor, token_hash).await?) +} + +fn encode(token: Token) -> TokenRow { + TokenRow { + id: token.id, + app_id: token.app_id, + access_token_hash: token.access_token_hash, + refresh_token_hash: token.refresh_token_hash, + access_expires_at: token.access_expires_at, + refresh_expires_at: token.refresh_expires_at, + revoked_at: token.revoked_at, + created_at: token.created_at, + } +} diff --git a/server/src/repository/user_app_secrets.rs b/server/src/repository/user_app_secrets.rs new file mode 100644 index 0000000..b803bc3 --- /dev/null +++ b/server/src/repository/user_app_secrets.rs @@ -0,0 +1,194 @@ +use uuid::Uuid; + +use super::{ + QueryConversionError, ReferenceRelation, ReferenceViolationKind, RepositoryError, dtos::Upsert, +}; +use crate::{ + database::{Constraint, DatabaseError, dtos::UserAppSecretRow, user_app_secrets as db}, + domain::UserAppSecret, +}; + +pub struct Query { + pub app_id: Uuid, + pub limit: Option, + pub offset: Option, +} + +impl Default for Query { + fn default() -> Self { + Self { + app_id: Uuid::nil(), + limit: None, + offset: None, + } + } +} + +impl TryFrom for db::Query { + type Error = QueryConversionError; + + fn try_from(query: Query) -> Result { + Ok(db::Query { + app_id: query.app_id, + limit: query + .limit + .map(|limit| i64::try_from(limit).map_err(|_| QueryConversionError::Limit(limit))) + .transpose()?, + offset: query + .offset + .map(|offset| { + i64::try_from(offset).map_err(|_| QueryConversionError::Offset(offset)) + }) + .transpose()?, + }) + } +} + +pub async fn list<'e, E>(executor: E, query: Query) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::query(executor, query.try_into()?) + .await? + .into_iter() + .map(decode) + .collect()) +} + +pub async fn get<'e, E>( + executor: E, + app_id: Uuid, + id: Uuid, +) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::get_by_id(executor, app_id, id).await?.map(decode)) +} + +pub async fn upsert<'e, E>( + executor: E, + secret: UserAppSecret, +) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let upsert = db::upsert(executor, encode(secret)) + .await + .map_err(classify_upsert_error)?; + + Ok(match upsert { + crate::database::dtos::Upsert::Created(row) => Upsert::Created(decode(row)), + crate::database::dtos::Upsert::Updated(row) => Upsert::Updated(decode(row)), + }) +} + +fn classify_upsert_error(error: DatabaseError) -> RepositoryError { + match &error { + DatabaseError::ForeignKeyViolation { + constraint: Constraint::UserAppSecretApp, + .. + } => RepositoryError::ReferenceViolation { + relation: ReferenceRelation::UserApp, + kind: ReferenceViolationKind::Missing, + source: error, + }, + _ => RepositoryError::Database(error), + } +} + +pub async fn verify<'e, E>( + executor: E, + app_id: Uuid, + secret_hash: &[u8], +) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::verify(executor, app_id, secret_hash).await?) +} + +pub async fn delete<'e, E>( + executor: E, + app_id: Uuid, + id: Uuid, +) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::delete_by_id(executor, app_id, id).await?.into()) +} + +fn decode(row: UserAppSecretRow) -> UserAppSecret { + UserAppSecret { + id: row.id, + app_id: row.app_id, + secret_hash: row.secret_hash, + expires_at: row.expires_at, + created_at: row.created_at, + } +} + +fn encode(secret: UserAppSecret) -> UserAppSecretRow { + UserAppSecretRow { + id: secret.id, + app_id: secret.app_id, + secret_hash: secret.secret_hash, + expires_at: secret.expires_at, + created_at: secret.created_at, + } +} + +#[cfg(test)] +mod tests { + use chrono::Utc; + + use super::*; + + fn foreign_key_violation(constraint: Constraint) -> DatabaseError { + DatabaseError::ForeignKeyViolation { + constraint, + source: sqlx::Error::Protocol("test database cause".to_owned()), + } + } + + #[test] + fn classifies_user_app_secret_upsert_foreign_key_violation() { + let error = classify_upsert_error(foreign_key_violation(Constraint::UserAppSecretApp)); + assert!(matches!( + error, + RepositoryError::ReferenceViolation { + relation: ReferenceRelation::UserApp, + kind: ReferenceViolationKind::Missing, + .. + } + )); + } + + #[test] + fn keeps_unknown_upsert_foreign_keys_generic() { + let error = classify_upsert_error(foreign_key_violation(Constraint::Unnamed)); + assert!(matches!(error, RepositoryError::Database(_))); + } + + fn row() -> UserAppSecretRow { + UserAppSecretRow { + id: Uuid::new_v4(), + app_id: Uuid::new_v4(), + secret_hash: vec![7; 32], + expires_at: Utc::now(), + created_at: Utc::now(), + } + } + + #[test] + fn round_trips_through_rows() { + let secret = decode(row()); + let round_trip = decode(encode(secret.clone())); + + assert_eq!(round_trip.id, secret.id); + assert_eq!(round_trip.app_id, secret.app_id); + assert_eq!(round_trip.secret_hash, secret.secret_hash); + assert_eq!(round_trip.expires_at, secret.expires_at); + } +} diff --git a/server/src/repository/user_apps.rs b/server/src/repository/user_apps.rs new file mode 100644 index 0000000..479b110 --- /dev/null +++ b/server/src/repository/user_apps.rs @@ -0,0 +1,172 @@ +use uuid::Uuid; + +use super::{QueryConversionError, RepositoryError, dtos::Upsert}; +use crate::{ + database::{Constraint, DatabaseError, dtos::UserAppRow, user_apps as db}, + domain::UserApp, +}; + +pub struct Query { + pub user_id: Uuid, + pub limit: Option, + pub offset: Option, +} + +impl Default for Query { + fn default() -> Self { + Self { + user_id: Uuid::nil(), + limit: None, + offset: None, + } + } +} + +impl TryFrom for db::Query { + type Error = QueryConversionError; + + fn try_from(query: Query) -> Result { + Ok(db::Query { + user_id: query.user_id, + limit: query + .limit + .map(|limit| i64::try_from(limit).map_err(|_| QueryConversionError::Limit(limit))) + .transpose()?, + offset: query + .offset + .map(|offset| { + i64::try_from(offset).map_err(|_| QueryConversionError::Offset(offset)) + }) + .transpose()?, + }) + } +} + +pub async fn list<'e, E>(executor: E, query: Query) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::query(executor, query.try_into()?) + .await? + .into_iter() + .map(decode) + .collect()) +} + +pub async fn get<'e, E>( + executor: E, + user_id: Uuid, + id: Uuid, +) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::get_by_id(executor, user_id, id).await?.map(decode)) +} + +pub async fn upsert<'e, E>(executor: E, app: UserApp) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let upsert = db::upsert(executor, encode(app)) + .await + .map_err(classify_upsert_error)?; + + Ok(match upsert { + crate::database::dtos::Upsert::Created(row) => Upsert::Created(decode(row)), + crate::database::dtos::Upsert::Updated(row) => Upsert::Updated(decode(row)), + }) +} + +fn classify_upsert_error(error: DatabaseError) -> RepositoryError { + match &error { + DatabaseError::ForeignKeyViolation { + constraint: Constraint::UserAppUser, + .. + } => RepositoryError::ReferenceViolation { + relation: super::ReferenceRelation::User, + kind: super::ReferenceViolationKind::Missing, + source: error, + }, + _ => RepositoryError::Database(error), + } +} + +pub async fn delete<'e, E>( + executor: E, + user_id: Uuid, + id: Uuid, +) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::delete_by_id(executor, user_id, id).await?.into()) +} + +fn decode(row: UserAppRow) -> UserApp { + UserApp { + id: row.id, + user_id: row.user_id, + } +} + +fn encode(app: UserApp) -> UserAppRow { + UserAppRow { + id: app.id, + user_id: app.user_id, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn foreign_key_violation(constraint: Constraint) -> DatabaseError { + DatabaseError::ForeignKeyViolation { + constraint, + source: sqlx::Error::Protocol("test database cause".to_owned()), + } + } + + #[test] + fn classifies_user_app_upsert_foreign_key_violation() { + let error = classify_upsert_error(foreign_key_violation(Constraint::UserAppUser)); + assert!(matches!( + error, + RepositoryError::ReferenceViolation { + relation: super::super::ReferenceRelation::User, + kind: super::super::ReferenceViolationKind::Missing, + .. + } + )); + } + + #[test] + fn keeps_unknown_upsert_foreign_keys_generic() { + let error = classify_upsert_error(foreign_key_violation(Constraint::Unnamed)); + assert!(matches!(error, RepositoryError::Database(_))); + } + + fn row() -> UserAppRow { + UserAppRow { + id: Uuid::new_v4(), + user_id: Uuid::new_v4(), + } + } + + #[test] + fn decodes_valid_rows() { + let row = row(); + let (id, user_id) = (row.id, row.user_id); + let app = decode(row); + + assert_eq!(app.id, id); + assert_eq!(app.user_id, user_id); + } + + #[test] + fn round_trips_through_rows() { + let app = decode(row()); + assert_eq!(decode(encode(app.clone())), app); + } +} diff --git a/server/src/routes.rs b/server/src/routes.rs index 2b626d8..01e6b46 100644 --- a/server/src/routes.rs +++ b/server/src/routes.rs @@ -2,30 +2,33 @@ use axum::{http::StatusCode, routing::get}; use crate::error::AppError; -pub mod accounts; -pub mod auth_passkey; -pub mod auth_token; -pub mod dtos; -pub mod extractors; -pub mod scheduled_transactions; -pub mod transactions; -pub mod users; +mod accounts; +mod auth_passkey; +mod auth_token; +mod dtos; +mod extractors; +mod scheduled_transactions; +mod transactions; +mod user_app_secrets; +mod user_apps; +mod users; pub fn create_router(pool: sqlx::PgPool) -> axum::Router { - let auth_passkey = auth_passkey::create_router(); - let auth_token = auth_token::create_router(); - let accounts = accounts::create_router(); - let scheduled_transactions = scheduled_transactions::create_router(); - let transactions = transactions::create_router(); - let users = users::create_router(); - let api = axum::Router::new() - .nest("/auth/passkey", auth_passkey) - .nest("/auth/token", auth_token) - .nest("/accounts", accounts) - .nest("/scheduled-transactions", scheduled_transactions) - .nest("/transactions", transactions) - .nest("/users", users); + .nest("/auth/passkey", auth_passkey::create_router()) + .nest("/auth/token", auth_token::create_router()) + .nest("/accounts", accounts::create_router()) + .nest( + "/scheduled-transactions", + scheduled_transactions::create_router(), + ) + .nest("/transactions", transactions::create_router()) + .nest("/users", users::create_router()) + .nest("/users/{user_id}/apps", user_apps::create_router()) + .nest( + "/users/{user_id}/apps/{app_id}/secrets", + user_app_secrets::create_router(), + ); axum::Router::new() .nest("/api", api) diff --git a/server/src/routes/auth_token.rs b/server/src/routes/auth_token.rs index 1108679..f990618 100644 --- a/server/src/routes/auth_token.rs +++ b/server/src/routes/auth_token.rs @@ -1,7 +1,21 @@ -use axum::routing::post; +use axum::{extract::State, routing::post}; +use chrono::{Duration, Utc}; use sqlx::PgPool; +use uuid::Uuid; -use crate::error::AppError; +use crate::{ + crypto::{generate_secret, hash_secret}, + domain::Token, + error::AppError, + repository::{self, user_app_secrets}, + routes::{ + dtos::token::{TokenRequest, TokenResponse, TokenRevocationRequest, TokenType}, + extractors::{form::Form, json::Json}, + }, +}; + +const ACCESS_TOKEN_LIFETIME_SECONDS: i64 = 3600; +const REFRESH_TOKEN_LIFETIME_SECONDS: i64 = 30 * 24 * 60 * 60; pub fn create_router() -> axum::Router { axum::Router::new() @@ -10,13 +24,110 @@ pub fn create_router() -> axum::Router { } #[axum::debug_handler] -#[tracing::instrument()] -async fn issue_token() -> Result<(), AppError> { - Ok(()) +#[tracing::instrument(skip(pool, token_request))] +async fn issue_token( + State(pool): State, + Form(token_request): Form, +) -> Result, AppError> { + match token_request { + TokenRequest::ClientCredentials { + client_id, + client_secret, + } => { + let secret_hash = hash_secret(&client_secret); + if !user_app_secrets::verify(&pool, client_id, &secret_hash).await? { + return Err(AppError::Unauthorized); + } + + let generated = generate_token_pair()?; + repository::tokens::issue(&pool, token(client_id, &generated)).await?; + + Ok(Json(token_response( + generated.access_token, + generated.refresh_token, + ))) + } + TokenRequest::RefreshToken { refresh_token } => { + let generated = generate_token_pair()?; + let old_refresh_hash = hash_secret(&refresh_token); + let mut tx = pool + .begin() + .await + .map_err(repository::RepositoryError::from)?; + let rotated = repository::tokens::rotate_refresh_token( + &mut *tx, + &old_refresh_hash, + &generated.access_token_hash, + &generated.refresh_token_hash, + generated.access_expires_at, + generated.refresh_expires_at, + ) + .await?; + if !rotated { + return Err(AppError::Unauthorized); + } + tx.commit() + .await + .map_err(repository::RepositoryError::from)?; + + Ok(Json(token_response( + generated.access_token, + generated.refresh_token, + ))) + } + } } #[axum::debug_handler] -#[tracing::instrument()] -async fn revoke_token() -> Result<(), AppError> { - Ok(()) +#[tracing::instrument(skip(pool, request))] +async fn revoke_token( + State(pool): State, + Form(request): Form, +) -> Result<(), AppError> { + Ok(repository::tokens::revoke(&pool, &hash_secret(&request.token)).await?) +} + +struct GeneratedTokenPair { + access_token: String, + refresh_token: String, + access_token_hash: Vec, + refresh_token_hash: Vec, + access_expires_at: chrono::DateTime, + refresh_expires_at: chrono::DateTime, +} + +fn generate_token_pair() -> Result { + let access_token = generate_secret().map_err(|_| AppError::Internal)?; + let refresh_token = generate_secret().map_err(|_| AppError::Internal)?; + let now = Utc::now(); + Ok(GeneratedTokenPair { + access_token_hash: hash_secret(&access_token), + refresh_token_hash: hash_secret(&refresh_token), + access_expires_at: now + Duration::seconds(ACCESS_TOKEN_LIFETIME_SECONDS), + refresh_expires_at: now + Duration::seconds(REFRESH_TOKEN_LIFETIME_SECONDS), + access_token, + refresh_token, + }) +} + +fn token(app_id: Uuid, generated: &GeneratedTokenPair) -> Token { + Token { + id: Uuid::new_v4(), + app_id, + access_token_hash: generated.access_token_hash.clone(), + refresh_token_hash: generated.refresh_token_hash.clone(), + access_expires_at: generated.access_expires_at, + refresh_expires_at: generated.refresh_expires_at, + revoked_at: None, + created_at: Utc::now(), + } +} + +fn token_response(access_token: String, refresh_token: String) -> TokenResponse { + TokenResponse { + access_token, + token_type: TokenType::Bearer, + expires_in: ACCESS_TOKEN_LIFETIME_SECONDS, + refresh_token: Some(refresh_token), + } } diff --git a/server/src/routes/dtos.rs b/server/src/routes/dtos.rs index 618d194..b110a98 100644 --- a/server/src/routes/dtos.rs +++ b/server/src/routes/dtos.rs @@ -1,5 +1,8 @@ pub mod account; pub mod direction; pub mod scheduled_transaction; +pub mod token; pub mod transaction; pub mod user; +pub mod user_app; +pub mod user_app_secret; diff --git a/server/src/routes/dtos/token.rs b/server/src/routes/dtos/token.rs new file mode 100644 index 0000000..0c83449 --- /dev/null +++ b/server/src/routes/dtos/token.rs @@ -0,0 +1,54 @@ +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +#[derive(Deserialize)] +#[serde(rename_all = "snake_case", tag = "grant_type")] +pub enum TokenRequest { + ClientCredentials { + client_id: Uuid, + client_secret: String, + }, + RefreshToken { + refresh_token: String, + }, +} + +#[derive(Deserialize)] +pub struct TokenRevocationRequest { + pub token: String, +} + +#[derive(Debug, Serialize)] +pub struct TokenResponse { + pub access_token: String, + pub token_type: TokenType, + pub expires_in: i64, + pub refresh_token: Option, +} + +#[derive(Debug, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum TokenType { + Bearer, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn serializes_token_response() { + let response = TokenResponse { + access_token: "access-token".to_string(), + token_type: TokenType::Bearer, + expires_in: 3600, + refresh_token: Some("refresh-token".to_string()), + }; + let value = serde_json::to_value(response).unwrap(); + + assert_eq!(value["access_token"], "access-token"); + assert_eq!(value["token_type"], "bearer"); + assert_eq!(value["expires_in"], 3600); + assert_eq!(value["refresh_token"], "refresh-token"); + } +} diff --git a/server/src/routes/dtos/user_app.rs b/server/src/routes/dtos/user_app.rs new file mode 100644 index 0000000..3fed19d --- /dev/null +++ b/server/src/routes/dtos/user_app.rs @@ -0,0 +1,53 @@ +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +use crate::domain; + +#[derive(Debug, Clone, Deserialize)] +pub struct UserAppRequest {} + +impl UserAppRequest { + pub fn into_domain(self, user_id: Uuid, id: Uuid) -> domain::UserApp { + domain::UserApp { id, user_id } + } +} + +#[derive(Debug, Clone, Serialize)] +pub struct UserAppResponse { + pub id: Uuid, +} + +impl From for UserAppResponse { + fn from(app: domain::UserApp) -> Self { + Self { id: app.id } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn serializes_user_app_response() { + let id = Uuid::new_v4(); + let response = UserAppResponse::from(domain::UserApp { + id, + user_id: Uuid::new_v4(), + }); + + assert_eq!( + serde_json::to_value(response).unwrap()["id"], + id.to_string() + ); + } + + #[test] + fn accepts_empty_put_payload() { + let request: UserAppRequest = serde_json::from_str("{}").unwrap(); + let user_id = Uuid::new_v4(); + let id = Uuid::new_v4(); + let app = request.into_domain(user_id, id); + + assert_eq!(app, domain::UserApp { id, user_id }); + } +} diff --git a/server/src/routes/dtos/user_app_secret.rs b/server/src/routes/dtos/user_app_secret.rs new file mode 100644 index 0000000..781e7ff --- /dev/null +++ b/server/src/routes/dtos/user_app_secret.rs @@ -0,0 +1,80 @@ +use chrono::{DateTime, FixedOffset, Utc}; +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +use crate::domain; + +#[derive(Debug, Clone, Deserialize)] +pub struct UserAppSecretRequest { + pub expires_at: DateTime, +} + +impl UserAppSecretRequest { + pub fn expires_at_utc(&self) -> DateTime { + self.expires_at.with_timezone(&Utc) + } +} + +#[derive(Debug, Clone, Serialize)] +pub struct UserAppSecretResponse { + pub id: Uuid, + pub app_id: Uuid, + pub expires_at: DateTime, + pub created_at: DateTime, +} + +impl From for UserAppSecretResponse { + fn from(secret: domain::UserAppSecret) -> Self { + Self { + id: secret.id, + app_id: secret.app_id, + expires_at: secret.expires_at, + created_at: secret.created_at, + } + } +} + +#[derive(Debug, Clone, Serialize)] +pub struct CreatedUserAppSecretResponse { + #[serde(flatten)] + pub credential: UserAppSecretResponse, + pub secret: String, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parses_timezone_aware_expiration() { + let request: UserAppSecretRequest = + serde_json::from_str(r#"{"expires_at":"2030-01-01T12:00:00+02:00"}"#).unwrap(); + + assert_eq!( + request.expires_at_utc().to_rfc3339(), + "2030-01-01T10:00:00+00:00" + ); + } + + #[test] + fn rejects_expiration_without_timezone() { + assert!( + serde_json::from_str::(r#"{"expires_at":"2030-01-01T12:00:00"}"#) + .is_err() + ); + } + + #[test] + fn read_response_does_not_expose_secret_hash() { + let response = UserAppSecretResponse { + id: Uuid::new_v4(), + app_id: Uuid::new_v4(), + expires_at: Utc::now(), + created_at: Utc::now(), + }; + let value = serde_json::to_value(response).unwrap(); + + assert!(value.get("secret").is_none()); + assert!(value.get("secret_hash").is_none()); + } +} diff --git a/server/src/routes/extractors.rs b/server/src/routes/extractors.rs index da8b727..f3a4443 100644 --- a/server/src/routes/extractors.rs +++ b/server/src/routes/extractors.rs @@ -1,3 +1,4 @@ +pub mod form; pub mod json; pub mod path; pub mod query; diff --git a/server/src/routes/extractors/form.rs b/server/src/routes/extractors/form.rs new file mode 100644 index 0000000..8bc69b4 --- /dev/null +++ b/server/src/routes/extractors/form.rs @@ -0,0 +1,21 @@ +use axum::extract::{FromRequest, Request}; +use serde::de::DeserializeOwned; + +use crate::error::AppError; + +pub struct Form(pub T); + +impl FromRequest for Form +where + T: DeserializeOwned, + S: Send + Sync, +{ + type Rejection = AppError; + + async fn from_request(request: Request, state: &S) -> Result { + axum::Form::::from_request(request, state) + .await + .map(|axum::Form(value)| Self(value)) + .map_err(|rejection| AppError::BadRequest(rejection.body_text())) + } +} diff --git a/server/src/routes/user_app_secrets.rs b/server/src/routes/user_app_secrets.rs new file mode 100644 index 0000000..41ed5fc --- /dev/null +++ b/server/src/routes/user_app_secrets.rs @@ -0,0 +1,123 @@ +use axum::{extract::State, http::StatusCode}; +use serde::Deserialize; +use sqlx::PgPool; +use uuid::Uuid; + +use super::{ + dtos::user_app_secret::{ + CreatedUserAppSecretResponse, UserAppSecretRequest, UserAppSecretResponse, + }, + extractors::{json::Json, path::Path, query::Query}, +}; +use crate::{ + crypto::{generate_secret, hash_secret}, + domain::UserAppSecret, + error::AppError, + repository::{ + dtos::{Delete, Upsert}, + user_app_secrets as repository, + }, +}; + +pub fn create_router() -> axum::Router { + axum::Router::new() + .route("/", axum::routing::get(list_user_app_secrets)) + .route( + "/{secret_id}", + axum::routing::get(get_user_app_secret) + .put(upsert_user_app_secret) + .delete(delete_user_app_secret), + ) +} + +#[derive(Debug, Deserialize)] +pub struct QueryParams { + pub limit: Option, + pub offset: Option, +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn list_user_app_secrets( + State(pool): State, + Path((user_id, app_id)): Path<(Uuid, Uuid)>, + Query(query): Query, +) -> Result>, AppError> { + let secrets = repository::list( + &pool, + repository::Query { + app_id, + limit: Some(query.limit.unwrap_or(20)), + offset: query.offset, + }, + ) + .await? + .into_iter() + .map(UserAppSecretResponse::from) + .collect(); + + Ok(Json(secrets)) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn get_user_app_secret( + State(pool): State, + Path((user_id, app_id, secret_id)): Path<(Uuid, Uuid, Uuid)>, +) -> Result, AppError> { + let secret = repository::get(&pool, app_id, secret_id) + .await? + .ok_or(AppError::NotFound)?; + + Ok(Json(secret.into())) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool, request))] +async fn upsert_user_app_secret( + State(pool): State, + Path((user_id, app_id, secret_id)): Path<(Uuid, Uuid, Uuid)>, + Json(request): Json, +) -> Result<(StatusCode, Json), AppError> { + let expires_at = request.expires_at_utc(); + if expires_at <= chrono::Utc::now() { + return Err(AppError::BadRequest( + "expires_at must be in the future".to_owned(), + )); + } + + let generated_secret = generate_secret().map_err(|_| AppError::Internal)?; + let secret = UserAppSecret { + id: secret_id, + app_id, + secret_hash: hash_secret(&generated_secret), + expires_at, + created_at: chrono::Utc::now(), + }; + let upsert = repository::upsert(&pool, secret).await?; + + let (status, secret) = match upsert { + Upsert::Created(secret) => (StatusCode::CREATED, secret), + Upsert::Updated(secret) => (StatusCode::OK, secret), + }; + + Ok(( + status, + Json(CreatedUserAppSecretResponse { + credential: secret.into(), + secret: generated_secret, + }), + )) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn delete_user_app_secret( + State(pool): State, + Path((user_id, app_id, secret_id)): Path<(Uuid, Uuid, Uuid)>, +) -> Result { + match repository::delete(&pool, app_id, secret_id).await? { + Delete::Deleted => Ok(StatusCode::NO_CONTENT), + Delete::NotFound => Err(AppError::NotFound), + } +} diff --git a/server/src/routes/user_apps.rs b/server/src/routes/user_apps.rs new file mode 100644 index 0000000..b02bd0d --- /dev/null +++ b/server/src/routes/user_apps.rs @@ -0,0 +1,99 @@ +use axum::{extract::State, http::StatusCode}; +use serde::Deserialize; +use sqlx::PgPool; +use uuid::Uuid; + +use super::{ + dtos::user_app::{UserAppRequest, UserAppResponse}, + extractors::{json::Json, path::Path, query::Query}, +}; +use crate::{ + error::AppError, + repository::{ + dtos::{Delete, Upsert}, + user_apps as repository, + }, +}; + +pub fn create_router() -> axum::Router { + axum::Router::new() + .route("/", axum::routing::get(list_user_apps)) + .route( + "/{app_id}", + axum::routing::get(get_user_app) + .put(upsert_user_app) + .delete(delete_user_app), + ) +} + +#[derive(Debug, Deserialize)] +pub struct QueryParams { + pub limit: Option, + pub offset: Option, +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn list_user_apps( + State(pool): State, + Path(user_id): Path, + Query(query): Query, +) -> Result>, AppError> { + let apps = repository::list( + &pool, + repository::Query { + user_id, + limit: Some(query.limit.unwrap_or(20)), + offset: query.offset, + }, + ) + .await? + .into_iter() + .map(UserAppResponse::from) + .collect(); + + Ok(Json(apps)) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn get_user_app( + State(pool): State, + Path((user_id, app_id)): Path<(Uuid, Uuid)>, +) -> Result, AppError> { + let app = repository::get(&pool, user_id, app_id) + .await? + .ok_or(AppError::NotFound)?; + + Ok(Json(app.into())) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool, request))] +async fn upsert_user_app( + State(pool): State, + Path((user_id, app_id)): Path<(Uuid, Uuid)>, + Json(request): Json, +) -> Result<(StatusCode, Json), AppError> { + let app = request.into_domain(user_id, app_id); + let upsert = repository::upsert(&pool, app).await?; + + let (status, app) = match upsert { + Upsert::Created(app) => (StatusCode::CREATED, app), + Upsert::Updated(app) => (StatusCode::OK, app), + }; + + Ok((status, Json(app.into()))) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn delete_user_app( + State(pool): State, + Path((user_id, app_id)): Path<(Uuid, Uuid)>, +) -> Result { + match repository::delete(&pool, user_id, app_id).await? { + Delete::Deleted => Ok(StatusCode::NO_CONTENT), + Delete::NotFound => Err(AppError::NotFound), + } +}