@moneypot/hub 1.20.0-dev.1 → 1.20.0-dev.3

package/dist/src/db/util.d.ts

@@ -1,7 +1,8 @@
 import { QueryResult, QueryResultRow } from "pg";
 import { PgClientResult } from "postgraphile/@dataplan/pg";
 import * as pg from "pg";
-export type QueryExecutor = Pick<pg.Pool, "query"> | Pick<pg.ClientBase, "query">;
+import { Prettify } from "../util.js";
+export type QueryExecutor = Prettify<Pick<pg.Pool, "query"> | Pick<pg.ClientBase, "query">>;
 type ResultType<T> = PgClientResult<T> | QueryResult<T extends QueryResultRow ? T : never>;
 export declare function maybeOneRow<T>(result: ResultType<T>): T | undefined;
 export declare function exactlyOneRow<T>(result: ResultType<T>): T;

package/dist/src/liability/internal/db.d.ts

@@ -1,5 +1,10 @@
 import { PgClientInTransaction } from "../../db/transaction.js";
+import { QueryExecutor } from "../../db/util.js";
 import { DbLiability } from "../types.js";
 export declare function dbLockLiability(pool: PgClientInTransaction, { id }: {
     id: string;
 }): Promise<DbLiability | null>;
+export declare function dbGetLiabilityByRef(pgClient: QueryExecutor, { refType, refId }: {
+    refType: string;
+    refId: string;
+}): Promise<DbLiability | null>;

package/dist/src/liability/internal/db.js

@@ -1,3 +1,4 @@
+import { maybeOneRow } from "../../db/util.js";
 export async function dbLockLiability(pool, { id }) {
     const result = await pool.query({
         text: `
@@ -10,3 +11,16 @@ export async function dbLockLiability(pool, { id }) {
     });
     return result.rows[0] ?? null;
 }
+export async function dbGetLiabilityByRef(pgClient, { refType, refId }) {
+    return pgClient
+        .query({
+        text: `
+      SELECT *
+      FROM hub.liability
+      WHERE ref_type = $1 AND ref_id = $2
+    `,
+        values: [refType, refId],
+    })
+        .then(maybeOneRow)
+        .then((row) => row ?? null);
+}

package/dist/src/liability/internal/index.d.ts

@@ -1,2 +1,2 @@
-export { dbLockLiability } from "./db.js";
-export { startLiabilityExpirationProcessor, processExpiredLiabilities, } from "./processor.js";
+export { dbLockLiability, dbGetLiabilityByRef } from "./db.js";
+export { startLiabilityDeadlineProcessor, processDeadlinedLiabilities, processOneDeadlinedLiability, } from "./processor.js";

package/dist/src/liability/internal/index.js

@@ -1,2 +1,2 @@
-export { dbLockLiability } from "./db.js";
-export { startLiabilityExpirationProcessor, processExpiredLiabilities, } from "./processor.js";
+export { dbLockLiability, dbGetLiabilityByRef } from "./db.js";
+export { startLiabilityDeadlineProcessor, processDeadlinedLiabilities, processOneDeadlinedLiability, } from "./processor.js";

package/dist/src/liability/internal/processor.d.ts

@@ -1,15 +1,20 @@
 import * as pg from "pg";
+import { type PgClientInTransaction } from "../../db/transaction.js";
 import { LiabilityConfigInternal } from "../public/config.js";
 import { QueryExecutor } from "../../db/util.js";
 export declare function dbGetLiabilityIdsPastDeadline(pgClient: QueryExecutor, { limit }?: {
     limit?: number;
 }): Promise<string[]>;
-export declare function startLiabilityExpirationProcessor<RefType extends string>({ signal, pool, liabilityConfig, }: {
+export declare function startLiabilityDeadlineProcessor<RefType extends string>({ signal, pool, liabilityConfig, }: {
     signal: AbortSignal;
     pool: pg.Pool;
     liabilityConfig: LiabilityConfigInternal<RefType>;
 }): void;
-export declare function processExpiredLiabilities<RefType extends string>({ pool, liabilityConfig, signal, }: {
+export declare function processOneDeadlinedLiability<RefType extends string>(pgClient: PgClientInTransaction, { liabilityConfig, liabilityId, }: {
+    liabilityConfig: LiabilityConfigInternal<RefType>;
+    liabilityId: string;
+}): Promise<void>;
+export declare function processDeadlinedLiabilities<RefType extends string>({ pool, liabilityConfig, signal, }: {
     pool: pg.Pool;
     liabilityConfig: LiabilityConfigInternal<RefType>;
     signal: AbortSignal;

package/dist/src/liability/internal/processor.js

@@ -1,6 +1,8 @@
 import { logger } from "../../logger.js";
 import { withPgPoolTransaction, } from "../../db/transaction.js";
 import { dbLockHouseBankroll, dbLockPlayerBalance } from "../../db/public.js";
+import { exactlyOneRow, maybeOneRow } from "../../db/util.js";
+import { abortableTimeout } from "../../util.js";
 const BATCH_SIZE = 100;
 export async function dbGetLiabilityIdsPastDeadline(pgClient, { limit = 100 } = {}) {
     const result = await pgClient.query({
@@ -17,7 +19,8 @@ export async function dbGetLiabilityIdsPastDeadline(pgClient, { limit = 100 } =
     return result.rows.map((r) => r.id);
 }
 async function dbTryLockLiabilityById(pgClient, id) {
-    const result = await pgClient.query({
+    return pgClient
+        .query({
         text: `
       SELECT *
       FROM hub.liability
@@ -26,15 +29,16 @@ async function dbTryLockLiabilityById(pgClient, id) {
       FOR UPDATE SKIP LOCKED
     `,
         values: [id],
-    });
-    return result.rows[0] ?? null;
+    })
+        .then(maybeOneRow)
+        .then((row) => row ?? null);
 }
-export function startLiabilityExpirationProcessor({ signal, pool, liabilityConfig, }) {
+export function startLiabilityDeadlineProcessor({ signal, pool, liabilityConfig, }) {
     if (signal.aborted) {
-        logger.info(`[startLiabilityExpirationProcessor] AbortSignal aborted. Not starting processor.`);
+        logger.info(`[startLiabilityDeadlineProcessor] AbortSignal aborted. Not starting processor.`);
         return;
     }
-    logger.info(`Starting liability expiration processor`);
+    logger.info(`Starting liability deadline processor`);
     (async () => {
         let shouldStop = false;
         signal.addEventListener("abort", () => {
@@ -42,19 +46,71 @@ export function startLiabilityExpirationProcessor({ signal, pool, liabilityConfi
         });
         while (!shouldStop && !signal.aborted) {
             try {
-                await processExpiredLiabilities({ pool, liabilityConfig, signal });
+                await processDeadlinedLiabilities({ pool, liabilityConfig, signal });
             }
             catch (e) {
-                logger.error(e, `Error processing expired liabilities`);
+                logger.error(e, `Error processing deadlined liabilities`);
             }
             if (!shouldStop && !signal.aborted) {
-                await new Promise((resolve) => setTimeout(resolve, liabilityConfig._options.pollIntervalMs));
+                await abortableTimeout(liabilityConfig._options.pollIntervalMs, signal);
             }
         }
-        logger.info(`Liability expiration processor stopped`);
+        logger.info(`Liability deadline processor stopped`);
     })();
 }
-export async function processExpiredLiabilities({ pool, liabilityConfig, signal, }) {
+export async function processOneDeadlinedLiability(pgClient, { liabilityConfig, liabilityId, }) {
+    const dbLockedLiability = await dbTryLockLiabilityById(pgClient, liabilityId);
+    if (!dbLockedLiability) {
+        return;
+    }
+    if (dbLockedLiability.deadline > new Date()) {
+        throw new Error(`Cannot process liability ${dbLockedLiability.id}: deadline has not passed (deadline: ${dbLockedLiability.deadline.toISOString()})`);
+    }
+    const refTypeConfig = liabilityConfig._refTypes[dbLockedLiability.ref_type];
+    if (!refTypeConfig?.handleDeadline) {
+        logger.error(`No handler configured for liability ref_type "${dbLockedLiability.ref_type}" (id: ${dbLockedLiability.id}). Skipping.`);
+        return;
+    }
+    const dbLockedPlayerBalance = await dbLockPlayerBalance(pgClient, {
+        userId: dbLockedLiability.user_id,
+        casinoId: dbLockedLiability.casino_id,
+        experienceId: dbLockedLiability.experience_id,
+        currencyKey: dbLockedLiability.currency_key,
+    });
+    if (!dbLockedPlayerBalance) {
+        logger.error(`No player balance found for liability ${dbLockedLiability.id}. Skipping.`);
+        return;
+    }
+    const dbLockedHouseBankroll = await dbLockHouseBankroll(pgClient, {
+        casinoId: dbLockedLiability.casino_id,
+        currencyKey: dbLockedLiability.currency_key,
+    });
+    if (!dbLockedHouseBankroll) {
+        logger.error(`No house bankroll found for liability ${dbLockedLiability.id}.`);
+        return;
+    }
+    try {
+        await refTypeConfig.handleDeadline({
+            pgClientInTransaction: pgClient,
+            lockedLiability: dbLockedLiability,
+            lockedPlayerBalance: dbLockedPlayerBalance,
+            lockedHouseBankroll: dbLockedHouseBankroll,
+        });
+        const { resolved_at } = await pgClient
+            .query(`SELECT resolved_at FROM hub.liability WHERE id = $1`, [dbLockedLiability.id])
+            .then(exactlyOneRow);
+        if (!resolved_at) {
+            throw new Error(`Handler returned LIABILITY_RESOLVED but did not resolve liability ${dbLockedLiability.id} (ref_type: ${dbLockedLiability.ref_type}, ref_id: ${dbLockedLiability.ref_id}). ` +
+                `Handler must call dbResolveLiabilityByRef before returning.`);
+        }
+        logger.debug(`Resolved liability ${dbLockedLiability.id}`);
+    }
+    catch (e) {
+        logger.error(e, `Error handling deadline for liability ${dbLockedLiability.id}`);
+        throw e;
+    }
+}
+export async function processDeadlinedLiabilities({ pool, liabilityConfig, signal, }) {
     const liabilityIds = await dbGetLiabilityIdsPastDeadline(pool, {
         limit: BATCH_SIZE,
     });
@@ -68,55 +124,10 @@ export async function processExpiredLiabilities({ pool, liabilityConfig, signal,
             break;
         }
         await withPgPoolTransaction(pool, async (pgClient) => {
-            const dbLockedLiability = await dbTryLockLiabilityById(pgClient, liabilityId);
-            if (!dbLockedLiability) {
-                return;
-            }
-            const refTypeConfig = liabilityConfig._refTypes[dbLockedLiability.ref_type];
-            if (!refTypeConfig?.handleDeadline) {
-                logger.error(`No handler configured for liability ref_type "${dbLockedLiability.ref_type}" (id: ${dbLockedLiability.id}). Skipping.`);
-                return;
-            }
-            const dbLockedPlayerBalance = await dbLockPlayerBalance(pgClient, {
-                userId: dbLockedLiability.user_id,
-                casinoId: dbLockedLiability.casino_id,
-                experienceId: dbLockedLiability.experience_id,
-                currencyKey: dbLockedLiability.currency_key,
+            await processOneDeadlinedLiability(pgClient, {
+                liabilityConfig,
+                liabilityId,
             });
-            if (!dbLockedPlayerBalance) {
-                logger.error(`No player balance found for liability ${dbLockedLiability.id}. Skipping.`);
-                return;
-            }
-            const dbLockedHouseBankroll = await dbLockHouseBankroll(pgClient, {
-                casinoId: dbLockedLiability.casino_id,
-                currencyKey: dbLockedLiability.currency_key,
-            });
-            if (!dbLockedHouseBankroll) {
-                logger.error(`No house bankroll found for liability ${dbLockedLiability.id}.`);
-                return;
-            }
-            try {
-                await refTypeConfig.handleDeadline({
-                    pgClientInTransaction: pgClient,
-                    lockedLiability: dbLockedLiability,
-                    lockedPlayerBalance: dbLockedPlayerBalance,
-                    lockedHouseBankroll: dbLockedHouseBankroll,
-                });
-                const { resolved_at } = await pgClient
-                    .query(`SELECT resolved_at FROM hub.liability WHERE id = $1`, [
-                    dbLockedLiability.id,
-                ])
-                    .then((r) => r.rows[0]);
-                if (!resolved_at) {
-                    throw new Error(`Handler returned LIABILITY_RESOLVED but did not resolve liability ${dbLockedLiability.id} (ref_type: ${dbLockedLiability.ref_type}, ref_id: ${dbLockedLiability.ref_id}). ` +
-                        `Handler must call dbResolveLiabilityByRef before returning.`);
-                }
-                logger.debug(`Resolved liability ${dbLockedLiability.id}`);
-            }
-            catch (e) {
-                logger.error(e, `Error handling expiration for liability ${dbLockedLiability.id}`);
-                throw e;
-            }
         });
     }
 }

package/dist/src/liability/public/config.d.ts

@@ -1,7 +1,6 @@
 import { DbLockedHouseBankrollWithAvailable, DbLockedPlayerBalance, PgClientInTransaction } from "../../db/index.js";
 import { Branded } from "../../util.js";
-import type { DbLiability } from "../types.js";
-import { dbCreateLiability, dbResolveLiabilityByRef } from "./db.js";
+import type { DbLiability, NewLiability } from "../types.js";
 export type DbLockedLiability<RefType extends string = string> = DbLiability & {
     ref_type: RefType;
 };
@@ -23,8 +22,14 @@ export declare function createLiabilityConfig<RefType extends string>(refTypes:
     [K in RefType]: LiabilityRefTypeConfig<K>;
 }, options?: Partial<LiabilityConfigOptions>): LiabilityConfig<RefType>;
 export type LiabilityConfig<RefType extends string> = {
-    dbCreateLiability: typeof dbCreateLiability<RefType>;
-    dbResolveLiabilityByRef: typeof dbResolveLiabilityByRef<RefType>;
+    dbCreateLiability: <T extends RefType>(pgClient: PgClientInTransaction, args: NewLiability<T>) => Promise<DbLiability & {
+        ref_type: T;
+    }>;
+    dbResolveLiabilityByRef: <T extends RefType>(pgClient: PgClientInTransaction, args: {
+        refType: T;
+        refId: string;
+        lockedBankrollId: string;
+    }) => Promise<boolean>;
 };
 export type LiabilityConfigOptions = {
     pollIntervalMs: number;

package/dist/src/process-transfers/polling-processor.js

@@ -1,7 +1,7 @@
 import * as db from "../db/index.js";
 import { logger } from "../logger.js";
 import { assert } from "tsafe";
-import { isUuid } from "../util.js";
+import { isUuid, abortableTimeout } from "../util.js";
 import { createGraphqlClient } from "../graphql-client.js";
 import { GET_CURRENCIES } from "../graphql-queries.js";
 import { processTakeRequests } from "../take-request/process-take-request.js";
@@ -75,7 +75,7 @@ export function startPollingProcessor({ casinoId, signal, pool, }) {
                 const now = Date.now();
                 const timeToWait = Math.max(0, processorState.backoffTime - (now - processorState.lastAttempt));
                 if (timeToWait > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, timeToWait));
+                    await abortableTimeout(timeToWait, signal);
                 }
                 processorState.lastAttempt = Date.now();
                 const casino = await dbGetCasinoById(pool, casinoId);
@@ -227,7 +227,6 @@ async function processWithdrawals({ abortSignal, casinoId, graphqlClient, pool,
 }
 async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoInfo, signal, pool, }) {
     let hasNextPage = true;
-    const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
     while (hasNextPage && !signal.aborted) {
         if (signal.aborted) {
             logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
@@ -276,7 +275,7 @@ async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoIn
             logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
             break;
         }
-        await timeout(1000);
+        await abortableTimeout(1000, signal);
     }
     return afterCursor;
 }

package/dist/src/process-transfers/websocket-processor.js

@@ -7,6 +7,7 @@ import { TRANSFER_FIELDS } from "./graphql.js";
 import { logger } from "../logger.js";
 import { processTransfer } from "./process-transfer.js";
 import assert from "assert";
+import { abortableTimeout } from "../util.js";
 import { mpGetTakeRequest, processSingleTakeRequest, } from "../take-request/process-take-request.js";
 function httpToWs(url) {
     if (url.protocol === "http:") {
@@ -64,7 +65,7 @@ export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controll
         retryWait: async (retries) => {
             const baseDelay = Math.min(1000 * Math.pow(2, retries), 30_000);
             const jitter = Math.floor(Math.random() * 10_000);
-            await new Promise((resolve) => setTimeout(resolve, baseDelay + jitter));
+            await abortableTimeout(baseDelay + jitter, signal);
         },
     });
     client.on("connected", () => {

package/dist/src/server/index.js

@@ -7,7 +7,7 @@ const postgraphile = typeof postgraphileImport === "function"
 import { createPreset, defaultPlugins } from "./graphile.config.js";
 import { createServerContext, closeServerContext, } from "../context.js";
 import { initializeTransferProcessors } from "../process-transfers/index.js";
-import { startLiabilityExpirationProcessor } from "../liability/internal/index.js";
+import { startLiabilityDeadlineProcessor } from "../liability/internal/index.js";
 import express from "express";
 import { logger } from "../logger.js";
 import cors from "./middleware/cors.js";
@@ -87,7 +87,7 @@ export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, ex
                     pool: context.superuserPool,
                 });
                 if (liabilityConfig) {
-                    startLiabilityExpirationProcessor({
+                    startLiabilityDeadlineProcessor({
                         signal: abortController.signal,
                         pool: context.superuserPool,
                         liabilityConfig: liabilityConfig,

package/dist/src/test/index.d.ts

@@ -1,13 +1,16 @@
-import { Pool, PoolClient } from "pg";
+import * as pg from "pg";
 import { DbUser, DbPlayerBalance, DbHashChain, DbCasino, DbExperience, DbCurrency, DbHouseBankroll } from "../db/types.js";
 import { GraphQLClient } from "graphql-request";
 import { ServerOptions } from "../index.js";
+import type { QueryExecutor } from "../db/util.js";
+import { LiabilityConfigInternal } from "../liability/public/config.js";
+export { type QueryExecutor };
 export declare function uniqueTestId(): string;
 export type HubTestServer = {
     port: number;
     stop: () => Promise<void>;
     destroy: () => Promise<void>;
-    dbPool: Pool;
+    dbPool: pg.Pool;
     playgroundCasinoId: string;
     authenticate: (userId: DbUser["id"], experienceId: DbExperience["id"]) => Promise<{
         sessionKey: string;
@@ -21,44 +24,48 @@ export type TestServerConfig = {
     extraPgSchemas?: string[];
 };
 export declare function startTestServer({ plugins, userDatabaseMigrationsPath, testId, extraPgSchemas, }: TestServerConfig): Promise<HubTestServer>;
-type PgClient = Pool | PoolClient;
-export declare function createUser(pgClient: PgClient, { casinoId, uname, }: {
+export declare function createUser(pgClient: QueryExecutor, { casinoId, uname, }: {
     casinoId: DbCasino["id"];
     uname: string;
 }): Promise<DbUser>;
-export declare function createPlayerBalance(pgClient: PgClient, { userId, experienceId, currencyKey, amount, }: {
+export declare function createPlayerBalance(pgClient: QueryExecutor, { userId, experienceId, currencyKey, amount, }: {
     userId: DbUser["id"];
     experienceId: DbExperience["id"];
     currencyKey: DbCurrency["key"];
     amount: number;
 }): Promise<DbPlayerBalance>;
-export declare function createHashChain(pgClient: PgClient, { userId, experienceId, casinoId, maxIterations, }: {
+export declare function createHashChain(pgClient: QueryExecutor, { userId, experienceId, casinoId, maxIterations, }: {
     userId: DbUser["id"];
     experienceId: DbExperience["id"];
     casinoId: DbCasino["id"];
     maxIterations?: number;
 }): Promise<DbHashChain>;
-export declare function createExperience(pgClient: PgClient, options: {
+export declare function createExperience(pgClient: QueryExecutor, options: {
     casinoId: DbCasino["id"];
 } | {
     casinoId: DbCasino["id"];
     mpExperienceId: string;
     name: string;
 }): Promise<DbExperience>;
-export declare function createCurrency(pgClient: PgClient, { key, casinoId, displayUnitName, displayUnitScale, }: {
+export declare function createCurrency(pgClient: QueryExecutor, { key, casinoId, displayUnitName, displayUnitScale, }: {
     key: DbCurrency["key"];
     casinoId: DbCasino["id"];
     displayUnitName: string;
     displayUnitScale: number;
 }): Promise<DbCurrency>;
-export declare function createHouseBankroll(pgClient: PgClient, { casinoId, currencyKey, amount, }: {
+export declare function createHouseBankroll(pgClient: QueryExecutor, { casinoId, currencyKey, amount, }: {
     casinoId: DbCasino["id"];
     currencyKey: DbCurrency["key"];
     amount: number;
 }): Promise<DbHouseBankroll>;
 export { createUser as createPlayer };
-export declare function getPlayerBalance(pgClient: PgClient, { userId, experienceId, currencyKey, }: {
+export declare function getPlayerBalance(pgClient: QueryExecutor, { userId, experienceId, currencyKey, }: {
     userId: DbUser["id"];
     experienceId: DbExperience["id"];
     currencyKey: DbCurrency["key"];
 }): Promise<DbPlayerBalance | null>;
+export declare function processOneDeadlinedLiability<RefType extends string>(dbPool: pg.Pool, { liabilityConfig, refType, refId, }: {
+    liabilityConfig: LiabilityConfigInternal<RefType>;
+    refType: RefType;
+    refId: string;
+}): Promise<void>;

package/dist/src/test/index.js

@@ -1,13 +1,14 @@
-import { Client, Pool } from "pg";
+import * as pg from "pg";
 import { randomBytes, randomUUID } from "node:crypto";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 const execAsync = promisify(exec);
 import { DbHashKind, } from "../db/types.js";
-import { exactlyOneRow, maybeOneRow } from "../db/index.js";
+import { exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
 import { GraphQLClient } from "graphql-request";
 import { defaultPlugins, runMigrations } from "../index.js";
 import { createHubServer } from "../server/index.js";
+import { dbGetLiabilityByRef, processOneDeadlinedLiability as internalProcessOneDeadlinedLiability, } from "../liability/internal/index.js";
 let testCounter = 0;
 export function uniqueTestId() {
     const workerId = process.env.VITEST_POOL_ID ?? "0";
@@ -20,7 +21,7 @@ export async function startTestServer({ plugins = [...defaultPlugins], userDatab
         await execAsync(`psql -U postgres -c "CREATE DATABASE \\"${dbName}\\""`);
     }
     catch (_e) {
-        const pool = new Pool({ connectionString });
+        const pool = new pg.Pool({ connectionString });
         try {
             await pool.query(`
         DROP SCHEMA IF EXISTS hub CASCADE;
@@ -38,7 +39,7 @@ export async function startTestServer({ plugins = [...defaultPlugins], userDatab
     process.env.LOG_LEVEL = process.env.LOG_LEVEL ?? "error";
     process.env.HASHCHAINSERVER_URL = "mock-server";
     process.env.HASHCHAINSERVER_APPLICATION_SECRET = "test-secret";
-    const pgClient = new Client({ connectionString });
+    const pgClient = new pg.Client({ connectionString });
     await pgClient.connect();
     try {
         await runMigrations({
@@ -61,7 +62,7 @@ export async function startTestServer({ plugins = [...defaultPlugins], userDatab
         postgraphileDatabaseUrl: connectionString,
     });
     const { port } = await hubServer.listen();
-    const dbPool = new Pool({ connectionString });
+    const dbPool = new pg.Pool({ connectionString });
     const url = `http://localhost:${port}`;
     const graphqlUrl = `${url}/graphql`;
     const { rows } = await dbPool.query("SELECT id FROM hub.casino WHERE is_playground = true LIMIT 1");
@@ -174,3 +175,15 @@ export async function getPlayerBalance(pgClient, { userId, experienceId, currenc
         .then(maybeOneRow)
         .then((row) => row ?? null);
 }
+export async function processOneDeadlinedLiability(dbPool, { liabilityConfig, refType, refId, }) {
+    await withPgPoolTransaction(dbPool, async (pgClient) => {
+        const dbLiability = await dbGetLiabilityByRef(pgClient, { refType, refId });
+        if (!dbLiability) {
+            throw new Error(`Liability not found: refType=${refType}, refId=${refId}`);
+        }
+        return internalProcessOneDeadlinedLiability(pgClient, {
+            liabilityConfig,
+            liabilityId: dbLiability.id,
+        });
+    });
+}

package/dist/src/util.d.ts

@@ -3,6 +3,9 @@ declare const BRAND: unique symbol;
 export type Branded<Brand, T> = T & {
     readonly [BRAND]: Brand;
 };
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 export declare function isUuid(input: any): boolean;
 export type Result<V, E> = {
     ok: true;
@@ -13,4 +16,5 @@ export type Result<V, E> = {
 };
 export declare function extractFirstZodErrorMessage(e: z.ZodError): string;
 export declare function uuidEqual(a: string, b: string): boolean;
+export declare function abortableTimeout(delay: number, signal: AbortSignal): Promise<void>;
 export {};

package/dist/src/util.js

@@ -1,4 +1,5 @@
 import { assert } from "tsafe";
+import { addAbortListener } from "node:events";
 const UUID_REGEX = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/;
 export function isUuid(input) {
     return typeof input === "string" && UUID_REGEX.test(input);
@@ -11,3 +12,17 @@ export function uuidEqual(a, b) {
     assert(isUuid(b), `Expected valid uuid string: "${b}"`);
     return a.toLowerCase() === b.toLowerCase();
 }
+export function abortableTimeout(delay, signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const disposable = addAbortListener(signal, () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+        const timeout = setTimeout(() => {
+            disposable[Symbol.dispose]();
+            resolve();
+        }, delay);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.20.0-dev.1",
+  "version": "1.20.0-dev.3",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [