88 lines
3.2 KiB
TypeScript
88 lines
3.2 KiB
TypeScript
/**
|
|
* Tenant plan lookup wiring for BullMQ priority resolution.
|
|
*
|
|
* The queue package's `resolveJobPriorityForTenant` accepts a pluggable
|
|
* `TenantPlanLookup`. This module registers one that reads from the
|
|
* subscription cache (two-tier, L1 in-process + L2 SharedStore) so each
|
|
* enqueue is a cheap synchronous-ish lookup instead of a DB hit.
|
|
*
|
|
* Plan-tier mapping is intentionally pluggable: the boilerplate has no
|
|
* hard-coded `enterprise|pro|free` field on tenants. Operators wire their
|
|
* own classifier via `setSubscriptionToPlanTier`. Until that is set, this
|
|
* lookup returns `null` for every tenant, which the resolver then maps to
|
|
* NORMAL. Internal jobs (`tenantId: null`) still get CRITICAL.
|
|
*
|
|
* Bootstrap:
|
|
* ```ts
|
|
* import { wireTenantPlanLookup } from "~/utils/services/.server/tenantPlanLookup.server";
|
|
* wireTenantPlanLookup();
|
|
* ```
|
|
* Call once during web boot — idempotent.
|
|
*/
|
|
import type { TenantPlanIdentifier } from "@hivegrid/queue";
|
|
import { setTenantPlanLookup } from "@hivegrid/queue";
|
|
import type { TenantSubscriptionWithDetails } from "@hivegrid/db/subscriptions.server";
|
|
import { getTenantSubscription } from "@hivegrid/db/subscriptions.server";
|
|
import { getSubscriptionCache } from "./subscriptionCache.server";
|
|
import { createScopedLogger } from "~/utils/logger.server";
|
|
|
|
const log = createScopedLogger("tenant-plan-lookup");
|
|
|
|
export type SubscriptionPlanClassifier = (
|
|
subscription: TenantSubscriptionWithDetails | null,
|
|
) => TenantPlanIdentifier | null;
|
|
|
|
let classifier: SubscriptionPlanClassifier = () => null;
|
|
let wired = false;
|
|
|
|
/**
|
|
* Replace the active classifier. Operators wire their own mapping
|
|
* (e.g. by stripe product id → "enterprise"|"pro"|"free"). Passing the
|
|
* default no-op classifier disables plan-based priority and falls back
|
|
* to NORMAL for all tenants.
|
|
*/
|
|
export function setSubscriptionToPlanTier(next: SubscriptionPlanClassifier): void {
|
|
classifier = next;
|
|
}
|
|
|
|
/**
|
|
* Cached lookup used by both the queue resolver and any caller that wants
|
|
* a cheap plan tier for the given tenant.
|
|
*/
|
|
export async function getCachedTenantPlan(tenantId: string): Promise<TenantPlanIdentifier | null> {
|
|
const cache = getSubscriptionCache();
|
|
let cached = await cache.get(tenantId);
|
|
if (cached === null) {
|
|
try {
|
|
const fresh = await getTenantSubscription(tenantId);
|
|
await cache.set(tenantId, fresh ?? null);
|
|
cached = fresh ?? null;
|
|
} catch (error) {
|
|
log.warn(
|
|
{ tenantId, error: error instanceof Error ? error.message : String(error) },
|
|
"getCachedTenantPlan: subscription fetch failed; returning null",
|
|
);
|
|
return null;
|
|
}
|
|
}
|
|
return classifier(cached);
|
|
}
|
|
|
|
/**
|
|
* Register the lookup on the queue package. Idempotent — calling twice is
|
|
* a no-op so per-request bootstraps don't churn the registration.
|
|
*/
|
|
export function wireTenantPlanLookup(): void {
|
|
if (wired) return;
|
|
wired = true;
|
|
setTenantPlanLookup((tenantId) => getCachedTenantPlan(tenantId));
|
|
log.info({}, "tenant plan lookup wired into queue priority resolver");
|
|
}
|
|
|
|
/** Test seam — drop the wiring + classifier. */
|
|
export function __resetTenantPlanLookupForTests(): void {
|
|
classifier = () => null;
|
|
wired = false;
|
|
setTenantPlanLookup(null);
|
|
}
|