A one-of-a-kind resume builder that keeps your privacy in mind. Completely secure, customizable, portable, open-source and free forever. Try it out today!
TypeScript agent-skillsaidsh-pluginhacktoberfestjavascriptmcp-serverreactresume-builderself-hostedtypescript
import type { AIProvider } from "@reactive-resume/ai/types";
import type { DbOrTx } from "@reactive-resume/db/client";
import type { AiAction, AiUsageSummary } from "@reactive-resume/schema/ai-usage";
import { ORPCError } from "@orpc/client";
import { and, count, eq, gte, inArray, lt, sql } from "drizzle-orm";
import { db } from "@reactive-resume/db/client";
import { aiRequest, user } from "@reactive-resume/db/schema";
import { generateId } from "@reactive-resume/utils/string";
import { assertProviderAvailable } from "../ai-providers/identity";
import { lockUser } from "../documents/ownership";
import { aiTransport } from "./url-policy";
export type AiUsage = {
userId: string;
operationId: string;
action: AiAction;
providerId: string;
label: string;
check?: ((reader: DbOrTx) => Promise<void>) | undefined;
};
/** Created only by authenticated server callers, before selecting an inference model. */
export function createAiUsage(
userId: string,
action: AiAction,
provider: { id: string; label: string },
check?: AiUsage["check"],
): AiUsage {
return {
userId,
operationId: generateId(),
action,
providerId: provider.id,
label: provider.label,
check,
};
}
/** Each SDK retry/tool step enters here once; consuming or replaying a stream never does. */
export function aiUsageTransport(usage: AiUsage, provider: AIProvider, model: string): { fetch: typeof fetch } {
const transport = aiTransport().fetch ?? fetch;
return {
fetch: async (input, init) => {
const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
signal?.throwIfAborted();
await db.transaction(async (tx) => {
await lockUser(tx, usage.userId);
await usage.check?.(tx);
await assertProviderAvailable(
{ id: usage.providerId, userId: usage.userId },
tx,
usage.action === "provider-test",
);
signal?.throwIfAborted();
// Reserve before I/O so failed/cancelled attempts survive. A crash here can leave delivery unknown.
await tx.insert(aiRequest).values({
userId: usage.userId,
operationId: usage.operationId,
action: usage.action,
providerId: usage.providerId,
label: usage.label,
provider,
model,
});
});
return transport(input, init);
},
};
}
/** A client may refer to a real request source; its account, action and model stay server-owned. */
export async function assertAiOperations(
userId: string,
operationIds: readonly string[],
actions: readonly AiAction[],
reader: DbOrTx,
) {
const ids = [...new Set(operationIds)];
if (!ids.length) return;
const rows = await reader
.selectDistinct({ id: aiRequest.operationId })
.from(aiRequest)
.where(
and(eq(aiRequest.userId, userId), inArray(aiRequest.operationId, ids), inArray(aiRequest.action, [...actions])),
);
if (rows.length !== ids.length)
throw new ORPCError("BAD_REQUEST", { message: "The AI request source is unavailable for this result." });
}
const selection = () => ({
providerId: aiRequest.providerId,
label: aiRequest.label,
provider: aiRequest.provider,
model: aiRequest.model,
});
export async function readAiUsages(userId: string, operationIds: readonly string[], reader: DbOrTx = db) {
const summaries = new Map<string, AiUsageSummary>();
if (!operationIds.length) return summaries;
const rows = await reader
.select({ operationId: aiRequest.operationId, ...selection(), requests: count() })
.from(aiRequest)
.where(and(eq(aiRequest.userId, userId), inArray(aiRequest.operationId, [...new Set(operationIds)])))
.groupBy(aiRequest.operationId, aiRequest.providerId, aiRequest.label, aiRequest.provider, aiRequest.model);
for (const { operationId, requests, ...model } of rows) {
const summary = summaries.get(operationId) ?? { requests: 0, models: [] };
summary.requests += requests;
summary.models.push(model);
summaries.set(operationId, summary);
}
return summaries;
}
export function combineAiUsage(summaries: Iterable<AiUsageSummary>): AiUsageSummary | null {
const rows = [...summaries];
if (!rows.length) return null;
return {
requests: rows.reduce((sum, row) => sum + row.requests, 0),
models: [...new Map(rows.flatMap((row) => row.models).map((model) => [JSON.stringify(model), model])).values()],
};
}
export async function readAiUsage(
userId: string,
operationIds: readonly string[],
reader: DbOrTx = db,
): Promise<AiUsageSummary | null> {
return combineAiUsage((await readAiUsages(userId, operationIds, reader)).values());
}
export async function readWeeklyAiUsage(userId: string, now = new Date(), includeWebSearch = false) {
const [owner] = await db.select({ timezone: user.timezone }).from(user).where(eq(user.id, userId));
if (!owner) throw new ORPCError("NOT_FOUND");
const timezone = owner.timezone ?? "UTC";
// PostgreSQL calendar arithmetic preserves local Monday boundaries through DST changes.
const bounds = await db.execute<{ start: string | Date; end: string | Date }>(sql`select
date_trunc('week', ${now.toISOString()}::timestamptz at time zone ${timezone}) at time zone ${timezone} as start,
(date_trunc('week', ${now.toISOString()}::timestamptz at time zone ${timezone}) + interval '1 week') at time zone ${timezone} as end`);
const boundary = bounds.rows[0];
if (!boundary) throw new Error("AI_USAGE_WEEK_UNAVAILABLE");
const range = { start: new Date(boundary.start), end: new Date(boundary.end) };
// Older clients have a closed action map; current clients opt into the distinct search action.
const action = includeWebSearch
? aiRequest.action
: sql<AiAction>`case when ${aiRequest.action} = 'web-search' then 'assistant' else ${aiRequest.action} end`;
const groups = await db
.select({ action, ...selection(), requests: count() })
.from(aiRequest)
.where(and(eq(aiRequest.userId, userId), gte(aiRequest.createdAt, range.start), lt(aiRequest.createdAt, range.end)))
.groupBy(action, aiRequest.providerId, aiRequest.label, aiRequest.provider, aiRequest.model)
.orderBy(aiRequest.label, action, aiRequest.model);
return { ...range, timezone, requests: groups.reduce((sum, row) => sum + row.requests, 0), groups };
}