@moneypot/hub 1.1.1 → 1.2.0-dev.1

package/dist/src/take-request/process-take-request.js

@@ -0,0 +1,783 @@
+import { gql } from "../__generated__/gql.js";
+import { TakeRequestStatus as MpTakeRequestStatus, TransferStatusKind as MpTransferStatus, } from "../__generated__/graphql.js";
+import { exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { assert } from "tsafe";
+import { pgAdvisoryLock } from "../pg-advisory-lock.js";
+const MP_PAGINATE_PENDING_TAKE_REQUESTS = gql(`
+  query MpPaginatedPendingTakeRequests($controllerId: UUID!, $after: Cursor) {
+    allTakeRequests(
+      condition: { controllerId: $controllerId, status: PENDING }
+      after: $after
+      orderBy: ID_ASC
+    ) {
+      pageInfo {
+        endCursor
+        hasNextPage
+      }
+      edges {
+        cursor
+        node {
+          id
+          status
+          amount
+          currencyKey
+          userId
+          experienceId
+          experienceTransfer {
+            id
+            amount
+          }
+        }
+      }
+    }
+  }
+`);
+const MP_REJECT_TAKE_REQUEST = gql(`
+  mutation MpRejectTakeRequest($mpTakeRequestId: UUID!) {
+    rejectTakeRequest(input: { id: $mpTakeRequestId }) {
+      result {
+        ... on RejectTakeRequestSuccess {
+          __typename
+          takeRequest {
+            id
+          }
+        }
+        ... on TakeRequestAlreadyTerminal {
+          __typename
+          takeRequest {
+            id
+            status
+          }
+        }
+      }
+    }
+  }
+`);
+const MP_TRANSFER_TAKE_REQUEST = gql(`
+  mutation MpTransferTakeRequest(
+    $mpTakeRequestId: UUID!
+    $mpExperienceId: UUID!
+    $mpUserId: UUID!
+    $amount: Int!
+    $currencyKey: String!
+  ) {
+    transferCurrencyExperienceToUser(
+      input: {
+        takeRequestId: $mpTakeRequestId
+        experienceId: $mpExperienceId
+        userId: $mpUserId
+        amount: $amount
+        currency: $currencyKey
+      }
+    ) {
+      result {
+        ... on TransferCurrencyExperienceToUserSuccess {
+          __typename
+          transfer {
+            id
+            status
+          }
+        }
+        ... on TransferMetadataIdExists {
+          __typename
+          transfer {
+            id
+            status
+          }
+        }
+        ... on TakeRequestAlreadyTerminal {
+          __typename
+          takeRequest {
+            id
+            status
+            experienceTransfer {
+              id
+              status
+            }
+          }
+        }
+      }
+    }
+  }
+`);
+const MP_COMPLETE_TRANSFER = gql(`
+  mutation CompleteTransfer2($mpTransferId: UUID!) {
+    completeTransfer(input: { id: $mpTransferId }) {
+      result {
+        ... on CompleteTransferSuccess {
+          __typename
+          transfer {
+            __typename
+            id
+            status
+            ... on ExperienceTransfer {
+              id
+              takeRequest {
+                id
+                status
+              }
+            }
+          }
+        }
+        ... on InvalidTransferStatus {
+          __typename
+          currentStatus
+          message
+          transfer {
+            __typename
+            ... on ExperienceTransfer {
+              id
+              takeRequest {
+                id
+                status
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`);
+var LocalTakeRequestStatus;
+(function (LocalTakeRequestStatus) {
+    LocalTakeRequestStatus["PENDING"] = "PENDING";
+    LocalTakeRequestStatus["PROCESSING"] = "PROCESSING";
+    LocalTakeRequestStatus["COMPLETED"] = "COMPLETED";
+    LocalTakeRequestStatus["FAILED"] = "FAILED";
+    LocalTakeRequestStatus["REJECTED"] = "REJECTED";
+})(LocalTakeRequestStatus || (LocalTakeRequestStatus = {}));
+export async function processTakeRequests({ abortSignal, controllerId, casinoId, graphqlClient, }) {
+    if (abortSignal.aborted) {
+        return;
+    }
+    const takeRequests = await fetchPendingTakeRequests(graphqlClient, controllerId);
+    console.log(`[processTakeRequests] Found ${takeRequests.length} take requests`);
+    for (const takeRequest of takeRequests) {
+        if (abortSignal.aborted) {
+            break;
+        }
+        await processSingleTakeRequest({
+            mpTakeRequestId: takeRequest.id,
+            mpTakeRequest: takeRequest,
+            casinoId,
+            graphqlClient,
+        });
+    }
+    await processPendingTransferCompletions({
+        casinoId,
+        graphqlClient,
+        abortSignal,
+    });
+    await processStuckRequests({ casinoId, graphqlClient, abortSignal });
+}
+async function fetchPendingTakeRequests(graphqlClient, controllerId) {
+    const result = await graphqlClient.request(MP_PAGINATE_PENDING_TAKE_REQUESTS, {
+        controllerId,
+    });
+    return (result.allTakeRequests?.edges.flatMap((edge) => edge?.node || []) || []);
+}
+async function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest, casinoId, graphqlClient, }) {
+    return withPgPoolTransaction(superuserPool, async (pgClient) => {
+        await pgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
+            mpTakeRequestId,
+            casinoId,
+        });
+        const existingRequest = await pgClient
+            .query({
+            text: `
+        SELECT id, mp_take_request_id, status, reserved_amount, user_id, experience_id, currency_key 
+        FROM hub.take_request 
+        WHERE mp_take_request_id = $1 AND casino_id = $2
+        FOR UPDATE
+      `,
+            values: [mpTakeRequestId, casinoId],
+        })
+            .then(maybeOneRow);
+        if (!existingRequest && mpTakeRequest) {
+            return await createAndProcessNewTakeRequest({
+                pgClient,
+                mpTakeRequest,
+                casinoId,
+                graphqlClient,
+            });
+        }
+        if (existingRequest) {
+            return await processExistingTakeRequest({
+                pgClient,
+                takeRequest: existingRequest,
+                casinoId,
+                graphqlClient,
+            });
+        }
+        console.log(`[processSingleTakeRequest] Take request ${mpTakeRequestId} not found in MP or our DB for casino ${casinoId}`);
+        return null;
+    });
+}
+async function createAndProcessNewTakeRequest({ pgClient, mpTakeRequest, casinoId, graphqlClient, }) {
+    assert(pgClient._inTransaction, "pgClient must be in a transaction");
+    assert(mpTakeRequest.status === MpTakeRequestStatus.Pending);
+    const { dbUser, dbExperience, dbCurrency, dbBalance } = await loadRequiredEntities(pgClient, {
+        type: "mpId",
+        mpUserId: mpTakeRequest.userId,
+        mpExperienceId: mpTakeRequest.experienceId,
+        currencyKey: mpTakeRequest.currencyKey,
+        casinoId,
+    });
+    if (!dbUser || !dbExperience || !dbCurrency || !dbBalance) {
+        await rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequest.id);
+        return null;
+    }
+    const amountToTransfer = Math.floor(typeof mpTakeRequest.amount === "number"
+        ? Math.min(mpTakeRequest.amount, dbBalance.amount)
+        : dbBalance.amount);
+    if (amountToTransfer < 1) {
+        await rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequest.id);
+        return null;
+    }
+    const newTakeRequest = await pgClient
+        .query({
+        text: `
+      INSERT INTO hub.take_request (
+        mp_take_request_id,
+        user_id,
+        experience_id,
+        casino_id,
+        currency_key,
+        amount,
+        status,
+        mp_status,
+        reserved_amount
+      )
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+      RETURNING id
+    `,
+        values: [
+            mpTakeRequest.id,
+            dbUser.id,
+            dbExperience.id,
+            casinoId,
+            dbCurrency.key,
+            mpTakeRequest.amount,
+            LocalTakeRequestStatus.PENDING,
+            mpTakeRequest.status,
+            amountToTransfer,
+        ],
+    })
+        .then(exactlyOneRow);
+    await pgClient.query({
+        text: `
+      UPDATE hub.balance
+      SET amount = amount - $1
+      WHERE id = $2
+    `,
+        values: [amountToTransfer, dbBalance.id],
+    });
+    await pgClient.query({
+        text: `
+      UPDATE hub.take_request
+      SET status = $1, updated_at = now()
+      WHERE id = $2
+    `,
+        values: [LocalTakeRequestStatus.PROCESSING, newTakeRequest.id],
+    });
+    return await attemptTransfer({
+        pgClient,
+        takeRequestId: newTakeRequest.id,
+        mpTakeRequestId: mpTakeRequest.id,
+        mpExperienceId: dbExperience.mp_experience_id,
+        mpUserId: dbUser.mp_user_id,
+        amount: amountToTransfer,
+        currencyKey: dbCurrency.key,
+        graphqlClient,
+    });
+}
+async function processExistingTakeRequest({ pgClient, takeRequest, casinoId, graphqlClient, }) {
+    assert(pgClient._inTransaction, "pgClient must be in a transaction");
+    switch (takeRequest.status) {
+        case LocalTakeRequestStatus.PENDING:
+            console.log(`[processExistingTakeRequest] Take request ${takeRequest.id} in PENDING state`);
+            break;
+        case LocalTakeRequestStatus.PROCESSING: {
+            const { dbUser, dbExperience, dbCurrency } = await loadRequiredEntities(pgClient, {
+                type: "localId",
+                userId: takeRequest.user_id,
+                experienceId: takeRequest.experience_id,
+                currencyKey: takeRequest.currency_key,
+                casinoId,
+            });
+            if (!dbUser || !dbExperience || !dbCurrency) {
+                await updateTakeRequestStatus(pgClient, takeRequest.id, LocalTakeRequestStatus.FAILED);
+                return null;
+            }
+            return await attemptTransfer({
+                pgClient,
+                takeRequestId: takeRequest.id,
+                mpTakeRequestId: takeRequest.mp_take_request_id,
+                mpExperienceId: dbExperience.mp_experience_id,
+                mpUserId: dbUser.mp_user_id,
+                amount: takeRequest.reserved_amount,
+                currencyKey: takeRequest.currency_key,
+                graphqlClient,
+            });
+        }
+        case LocalTakeRequestStatus.COMPLETED:
+            console.log(`[processExistingTakeRequest] Take request ${takeRequest.id} already COMPLETED`);
+            break;
+        case LocalTakeRequestStatus.FAILED:
+            console.log(`[processExistingTakeRequest] Take request ${takeRequest.id} in FAILED state`);
+            break;
+        case LocalTakeRequestStatus.REJECTED:
+            console.log(`[processExistingTakeRequest] Take request ${takeRequest.id} already REJECTED`);
+            break;
+        default:
+            console.error(`[processExistingTakeRequest] Unknown status: ${takeRequest.status}`);
+            break;
+    }
+    return null;
+}
+async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExperienceId, mpUserId, amount, currencyKey, graphqlClient, }) {
+    assert(pgClient._inTransaction, "pgClient must be in a transaction");
+    try {
+        const transferResult = await graphqlClient.request(MP_TRANSFER_TAKE_REQUEST, {
+            mpTakeRequestId,
+            mpExperienceId,
+            mpUserId,
+            amount,
+            currencyKey,
+        });
+        if (!transferResult.transferCurrencyExperienceToUser?.result) {
+            throw new Error("No transfer result");
+        }
+        const result = transferResult.transferCurrencyExperienceToUser.result;
+        let transferId = null;
+        let resultStatus = LocalTakeRequestStatus.PROCESSING;
+        switch (result.__typename) {
+            case "TransferCurrencyExperienceToUserSuccess":
+                transferId = result.transfer.id;
+                break;
+            case "TransferMetadataIdExists":
+                transferId = result.transfer.id;
+                break;
+            case "TakeRequestAlreadyTerminal": {
+                const mpStatus = result.takeRequest.status;
+                if (result.takeRequest.experienceTransfer) {
+                    transferId = result.takeRequest.experienceTransfer.id;
+                    if (mpStatus === MpTakeRequestStatus.UserCanceled) {
+                        resultStatus = LocalTakeRequestStatus.FAILED;
+                    }
+                }
+                else {
+                    resultStatus = LocalTakeRequestStatus.FAILED;
+                }
+                break;
+            }
+            default:
+                throw new Error(`Unexpected result type: ${result.__typename}`);
+        }
+        await pgClient.query({
+            text: `
+        UPDATE hub.take_request
+        SET status = $1, 
+            mp_transfer_id = $2, 
+            mp_transfer_status = $3,
+            transfer_needs_completion = $4,
+            mp_status = $5
+        WHERE id = $6
+      `,
+            values: [
+                resultStatus,
+                transferId,
+                MpTransferStatus.Pending,
+                true,
+                result.__typename === "TakeRequestAlreadyTerminal"
+                    ? result.takeRequest.status
+                    : MpTakeRequestStatus.Pending,
+                takeRequestId,
+            ],
+        });
+        return transferId;
+    }
+    catch (error) {
+        console.error(`[attemptTransfer] Error: ${error}`);
+        await pgClient.query({
+            text: `
+        UPDATE hub.take_request
+        SET status = $1
+        WHERE id = $2
+      `,
+            values: [LocalTakeRequestStatus.FAILED, takeRequestId],
+        });
+        return null;
+    }
+}
+async function processPendingTransferCompletions({ casinoId, graphqlClient, abortSignal, }) {
+    if (abortSignal.aborted) {
+        return;
+    }
+    const pendingCompletions = await superuserPool
+        .query({
+        text: `
+      SELECT id, mp_take_request_id, mp_transfer_id, transfer_completion_attempted_at
+      FROM hub.take_request
+      WHERE casino_id = $1
+        AND mp_transfer_id IS NOT NULL
+        AND transfer_needs_completion = TRUE
+        AND (
+          transfer_completion_attempted_at IS NULL OR
+          transfer_completion_attempted_at < now() - CASE
+            -- Exponential backoff: 10s, 1m, 5m, 15m, 30m, 1h, 3h
+            WHEN transfer_completion_attempted_at IS NULL THEN interval '0 seconds'
+            WHEN transfer_completion_attempted_at > now() - interval '10 minutes' THEN interval '10 seconds'
+            WHEN transfer_completion_attempted_at > now() - interval '30 minutes' THEN interval '1 minute'
+            WHEN transfer_completion_attempted_at > now() - interval '1 hour' THEN interval '5 minutes'
+            WHEN transfer_completion_attempted_at > now() - interval '3 hours' THEN interval '15 minutes'
+            WHEN transfer_completion_attempted_at > now() - interval '6 hours' THEN interval '30 minutes'
+            WHEN transfer_completion_attempted_at > now() - interval '24 hours' THEN interval '1 hour'
+            ELSE interval '3 hours'
+          END
+        )
+      LIMIT 10
+    `,
+        values: [casinoId],
+    })
+        .then((result) => result.rows);
+    console.log(`[processPendingTransferCompletions] Found ${pendingCompletions.length} transfers needing completion`);
+    for (const request of pendingCompletions) {
+        if (abortSignal.aborted) {
+            break;
+        }
+        await completeTransfer({
+            mpTakeRequestId: request.mp_take_request_id,
+            takeRequestId: request.id,
+            mpTransferId: request.mp_transfer_id,
+            graphqlClient,
+            casinoId,
+        });
+    }
+}
+async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTransferId, graphqlClient, casinoId, }) {
+    return withPgPoolTransaction(superuserPool, async (pgClient) => {
+        await pgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
+            mpTakeRequestId,
+            casinoId,
+        });
+        await pgClient.query({
+            text: `
+        UPDATE hub.take_request
+        SET transfer_completion_attempted_at = now()
+        WHERE id = $1
+      `,
+            values: [takeRequestId],
+        });
+        try {
+            const result = await graphqlClient.request(MP_COMPLETE_TRANSFER, {
+                mpTransferId,
+            });
+            const completionResult = result.completeTransfer?.result;
+            if (!completionResult) {
+                throw new Error("No completion result returned from MP API");
+            }
+            switch (completionResult.__typename) {
+                case "CompleteTransferSuccess":
+                    await pgClient.query({
+                        text: `
+              UPDATE hub.take_request
+              SET 
+                transfer_needs_completion = FALSE,
+                mp_transfer_status = $2,
+                status = $3,
+                mp_status = $4
+              WHERE id = $1
+            `,
+                        values: [
+                            takeRequestId,
+                            completionResult.transfer.status,
+                            LocalTakeRequestStatus.COMPLETED,
+                            MpTakeRequestStatus.Transferred,
+                        ],
+                    });
+                    console.log(`[completeTransfer] Successfully completed transfer ${mpTransferId}`);
+                    break;
+                case "InvalidTransferStatus": {
+                    const currentStatus = completionResult.currentStatus;
+                    if (currentStatus === "COMPLETED") {
+                        await pgClient.query({
+                            text: `
+                UPDATE hub.take_request
+                SET 
+                  transfer_needs_completion = FALSE,
+                  mp_transfer_status = $2,
+                  status = $3,
+                  mp_status = $4
+                WHERE id = $1
+              `,
+                            values: [
+                                takeRequestId,
+                                currentStatus,
+                                LocalTakeRequestStatus.COMPLETED,
+                                MpTakeRequestStatus.Transferred,
+                            ],
+                        });
+                        console.log(`[completeTransfer] Transfer ${mpTransferId} was already completed`);
+                    }
+                    else if (currentStatus === "CANCELED" ||
+                        currentStatus === "EXPIRED") {
+                        const mpStatus = completionResult.transfer.__typename === "ExperienceTransfer"
+                            ? completionResult.transfer.takeRequest?.status
+                            : null;
+                        if (!mpStatus) {
+                            throw new Error("No MP status returned from MP API");
+                        }
+                        await pgClient.query({
+                            text: `
+                UPDATE hub.take_request
+                SET 
+                  transfer_needs_completion = FALSE,
+                  mp_transfer_status = $2,
+                  status = $3,
+                  mp_status = $4
+                WHERE id = $1
+              `,
+                            values: [
+                                takeRequestId,
+                                currentStatus,
+                                LocalTakeRequestStatus.FAILED,
+                                mpStatus,
+                            ],
+                        });
+                        console.log(`[completeTransfer] Transfer ${mpTransferId} has status ${currentStatus}`);
+                    }
+                    else {
+                        console.log(`[completeTransfer] Transfer ${mpTransferId} has status ${currentStatus}, will retry later`);
+                    }
+                    break;
+                }
+                default: {
+                    const exhaustiveCheck = completionResult;
+                    throw new Error(`Unknown completion result type: ${exhaustiveCheck}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[completeTransfer] Error completing transfer ${mpTransferId}:`, error);
+        }
+    });
+}
+async function processStuckRequests({ casinoId, graphqlClient, abortSignal, }) {
+    if (abortSignal.aborted) {
+        return;
+    }
+    const stuckRequests = await superuserPool
+        .query({
+        text: `
+      SELECT id, mp_take_request_id
+      FROM hub.take_request
+      WHERE casino_id = $1
+        AND status = $2
+        AND mp_transfer_id IS NULL
+        AND updated_at < now() - interval '5 minutes'
+      LIMIT 10
+    `,
+        values: [casinoId, LocalTakeRequestStatus.PROCESSING],
+    })
+        .then((result) => result.rows);
+    console.log(`[processStuckRequests] Found ${stuckRequests.length} stuck take requests`);
+    for (const request of stuckRequests) {
+        if (abortSignal.aborted) {
+            break;
+        }
+        await processSingleTakeRequest({
+            mpTakeRequestId: request.mp_take_request_id,
+            casinoId,
+            graphqlClient,
+        });
+    }
+}
+async function loadRequiredEntities(pgClient, params) {
+    const { type, currencyKey, casinoId } = params;
+    assert(pgClient._inTransaction, "pgClient must be in a transaction");
+    const dbCurrency = await pgClient
+        .query({
+        text: `
+        SELECT key
+        FROM hub.currency
+        WHERE key = $1 AND casino_id = $2
+      `,
+        values: [currencyKey, casinoId],
+    })
+        .then(maybeOneRow);
+    if (!dbCurrency) {
+        console.warn(`[loadRequiredEntities] Currency ${currencyKey} not found`);
+        return {
+            dbCurrency: null,
+            dbUser: null,
+            dbExperience: null,
+            dbBalance: null,
+        };
+    }
+    let dbUser;
+    if (type === "localId") {
+        dbUser = await pgClient
+            .query({
+            text: `
+          SELECT *
+          FROM hub.user
+          WHERE id = $1 AND casino_id = $2
+        `,
+            values: [params.userId, casinoId],
+        })
+            .then(maybeOneRow);
+    }
+    else {
+        dbUser = await pgClient
+            .query({
+            text: `
+          SELECT *
+          FROM hub.user
+          WHERE mp_user_id = $1 AND casino_id = $2
+        `,
+            values: [params.mpUserId, casinoId],
+        })
+            .then(maybeOneRow);
+    }
+    if (!dbUser) {
+        console.warn(`[loadRequiredEntities] User not found`);
+        return { dbCurrency, dbUser: null, dbExperience: null, dbBalance: null };
+    }
+    let dbExperience;
+    if (type === "localId") {
+        dbExperience = await pgClient
+            .query({
+            text: `
+          SELECT *
+          FROM hub.experience
+          WHERE id = $1 AND casino_id = $2
+        `,
+            values: [params.experienceId, casinoId],
+        })
+            .then(maybeOneRow);
+    }
+    else {
+        dbExperience = await pgClient
+            .query({
+            text: `
+          SELECT *
+          FROM hub.experience
+          WHERE mp_experience_id = $1 AND casino_id = $2
+        `,
+            values: [params.mpExperienceId, casinoId],
+        })
+            .then(maybeOneRow);
+    }
+    if (!dbExperience) {
+        console.warn(`[loadRequiredEntities] Experience not found`);
+        return { dbCurrency, dbUser, dbExperience: null, dbBalance: null };
+    }
+    let dbBalance = null;
+    if (dbUser && dbExperience) {
+        dbBalance = await pgClient
+            .query({
+            text: `
+          SELECT id, amount
+          FROM hub.balance
+          WHERE user_id = $1 
+            AND experience_id = $2 
+            AND casino_id = $3 
+            AND currency_key = $4
+          FOR UPDATE
+        `,
+            values: [dbUser.id, dbExperience.id, casinoId, dbCurrency.key],
+        })
+            .then(maybeOneRow)
+            .then((row) => row ?? null);
+    }
+    return { dbCurrency, dbUser, dbExperience, dbBalance };
+}
+async function rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequestId, takeRequestId) {
+    assert(pgClient._inTransaction, "pgClient must be in a transaction");
+    try {
+        console.log(`[rejectMpTakeRequest] Rejecting take request ${mpTakeRequestId}`);
+        const rejectResult = await graphqlClient.request(MP_REJECT_TAKE_REQUEST, {
+            mpTakeRequestId,
+        });
+        let success = false;
+        let updatedMpStatus = null;
+        switch (rejectResult.rejectTakeRequest.result.__typename) {
+            case "RejectTakeRequestSuccess":
+                updatedMpStatus = MpTakeRequestStatus.ControllerRejected;
+                success = true;
+                break;
+            case "TakeRequestAlreadyTerminal":
+                if (rejectResult.rejectTakeRequest.result.takeRequest?.status) {
+                    updatedMpStatus = rejectResult.rejectTakeRequest.result.takeRequest
+                        .status;
+                }
+                success = true;
+                break;
+            default: {
+                const exhaustiveCheck = rejectResult.rejectTakeRequest.result;
+                throw new Error(`Unexpected result type: ${exhaustiveCheck}`);
+            }
+        }
+        if (updatedMpStatus) {
+            if (takeRequestId) {
+                await pgClient.query({
+                    text: `
+            UPDATE hub.take_request
+            SET status = $1, 
+                mp_status = $2
+            WHERE id = $3
+          `,
+                    values: [
+                        LocalTakeRequestStatus.REJECTED,
+                        updatedMpStatus,
+                        takeRequestId,
+                    ],
+                });
+            }
+            else {
+                const existingRequest = await pgClient
+                    .query({
+                    text: `
+            SELECT id FROM hub.take_request
+            WHERE mp_take_request_id = $1
+            FOR UPDATE
+          `,
+                    values: [mpTakeRequestId],
+                })
+                    .then(maybeOneRow);
+                if (existingRequest) {
+                    await pgClient.query({
+                        text: `
+              UPDATE hub.take_request
+              SET status = $1, 
+                  mp_status = $2
+              WHERE id = $3
+            `,
+                        values: [
+                            LocalTakeRequestStatus.REJECTED,
+                            updatedMpStatus,
+                            existingRequest.id,
+                        ],
+                    });
+                }
+            }
+        }
+        return success;
+    }
+    catch (error) {
+        console.error(`[rejectMpTakeRequest] Error: ${error}`);
+        return false;
+    }
+}
+async function updateTakeRequestStatus(pgClient, takeRequestId, status) {
+    assert(pgClient._inTransaction, "pgClient must be in a transaction");
+    return pgClient.query({
+        text: `
+      UPDATE hub.take_request
+      SET status = $1, updated_at = now()
+      WHERE id = $2
+    `,
+        values: [status, takeRequestId],
+    });
+}