478 lines
20 KiB
TypeScript
478 lines
20 KiB
TypeScript
import { readFile, rename, writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { createClient, type SupabaseClient } from "@supabase/supabase-js";
|
|
import { createId } from "@/lib/server/ids";
|
|
import { dataDir, ensureRuntimeDirs } from "@/lib/server/runtime";
|
|
import type {
|
|
BillingCurrency,
|
|
BillingLedgerEntry,
|
|
BillingLedgerKind,
|
|
BillingParameterDimension,
|
|
BillingPriceRule,
|
|
BillingRuleConditions,
|
|
OrganizationWallet
|
|
} from "@/lib/types";
|
|
|
|
const STORE_FILE = "billing-state.json";
|
|
let localWriteQueue: Promise<unknown> = Promise.resolve();
|
|
|
|
type BillingState = {
|
|
priceRules: BillingPriceRule[];
|
|
wallets: OrganizationWallet[];
|
|
ledgerEntries: BillingLedgerEntry[];
|
|
};
|
|
|
|
export type BillingPriceRuleInput = Omit<BillingPriceRule, "id" | "createdAt" | "updatedAt"> & Partial<Pick<BillingPriceRule, "id" | "createdAt" | "updatedAt">>;
|
|
|
|
export type BillingLedgerFilters = {
|
|
organizationId?: string;
|
|
accountId?: string;
|
|
jobId?: string;
|
|
kind?: BillingLedgerKind;
|
|
limit?: number;
|
|
};
|
|
|
|
export type WalletEntryInput = {
|
|
organizationId: string;
|
|
accountId?: string;
|
|
jobId?: string;
|
|
kind: BillingLedgerKind;
|
|
deltaFen: number;
|
|
currency?: BillingCurrency;
|
|
idempotencyKey: string;
|
|
description: string;
|
|
metadata?: Record<string, unknown>;
|
|
};
|
|
|
|
export class BillingStoreError extends Error {
|
|
status: number;
|
|
|
|
constructor(message: string, status = 400) {
|
|
super(normalizeBillingStoreErrorMessage(message));
|
|
this.name = "BillingStoreError";
|
|
this.status = status;
|
|
}
|
|
}
|
|
|
|
export class InsufficientBalanceError extends BillingStoreError {
|
|
constructor(message = "余额不足，请先充值。") {
|
|
super(message, 402);
|
|
this.name = "InsufficientBalanceError";
|
|
}
|
|
}
|
|
|
|
export async function listBillingPriceRules(options: { includeDisabled?: boolean } = {}): Promise<BillingPriceRule[]> {
|
|
const supabase = getSupabaseAdmin();
|
|
if (supabase) {
|
|
let query = supabase.from("billing_price_rules").select("*").order("provider").order("capability").order("updated_at", { ascending: false });
|
|
if (!options.includeDisabled) query = query.eq("enabled", true);
|
|
const { data, error } = await query;
|
|
if (error) throw new BillingStoreError(error.message, 500);
|
|
return (data || []).map(priceRuleFromRow);
|
|
}
|
|
const state = await readState();
|
|
return state.priceRules
|
|
.filter((rule) => options.includeDisabled || rule.enabled)
|
|
.sort((left, right) => left.provider.localeCompare(right.provider) || left.capability.localeCompare(right.capability) || right.updatedAt.localeCompare(left.updatedAt));
|
|
}
|
|
|
|
export async function getBillingPriceRule(id: string): Promise<BillingPriceRule | null> {
|
|
const supabase = getSupabaseAdmin();
|
|
if (supabase) {
|
|
const { data, error } = await supabase.from("billing_price_rules").select("*").eq("id", id).maybeSingle();
|
|
if (error) throw new BillingStoreError(error.message, 500);
|
|
return data ? priceRuleFromRow(data) : null;
|
|
}
|
|
const state = await readState();
|
|
return state.priceRules.find((rule) => rule.id === id) || null;
|
|
}
|
|
|
|
export async function createBillingPriceRule(input: BillingPriceRuleInput): Promise<BillingPriceRule> {
|
|
const now = new Date().toISOString();
|
|
const rule: BillingPriceRule = {
|
|
...input,
|
|
id: input.id || createId("price"),
|
|
createdAt: input.createdAt || now,
|
|
updatedAt: input.updatedAt || now
|
|
};
|
|
const supabase = getSupabaseAdmin();
|
|
if (supabase) {
|
|
const { data, error } = await supabase.from("billing_price_rules").insert(priceRuleToRow(rule)).select("*").single();
|
|
if (error) throw new BillingStoreError(error.message, error.code === "23505" ? 409 : 500);
|
|
return priceRuleFromRow(data);
|
|
}
|
|
return mutateLocalState((state) => {
|
|
if (state.priceRules.some((item) => item.id === rule.id)) throw new BillingStoreError("计费规则 ID 已存在。", 409);
|
|
if (state.priceRules.some((item) => priceRuleMatchKey(item) === priceRuleMatchKey(rule))) {
|
|
throw new BillingStoreError("相同服务商、能力、模型和变体的计费规则已存在。", 409);
|
|
}
|
|
state.priceRules.unshift(rule);
|
|
return rule;
|
|
});
|
|
}
|
|
|
|
export async function updateBillingPriceRule(id: string, patch: Partial<Omit<BillingPriceRule, "id" | "createdAt" | "updatedAt">>): Promise<BillingPriceRule | null> {
|
|
const existing = await getBillingPriceRule(id);
|
|
if (!existing) return null;
|
|
const updated: BillingPriceRule = { ...existing, ...patch, updatedAt: new Date().toISOString() };
|
|
const supabase = getSupabaseAdmin();
|
|
if (supabase) {
|
|
const { data, error } = await supabase.from("billing_price_rules").update(priceRuleToRow(updated)).eq("id", id).select("*").maybeSingle();
|
|
if (error) throw new BillingStoreError(error.message, 500);
|
|
return data ? priceRuleFromRow(data) : null;
|
|
}
|
|
return mutateLocalState((state) => {
|
|
const index = state.priceRules.findIndex((item) => item.id === id);
|
|
if (index === -1) return null;
|
|
if (state.priceRules.some((item) => item.id !== id && priceRuleMatchKey(item) === priceRuleMatchKey(updated))) {
|
|
throw new BillingStoreError("相同服务商、能力、模型和参数条件的计费规则已存在。", 409);
|
|
}
|
|
state.priceRules[index] = updated;
|
|
return updated;
|
|
});
|
|
}
|
|
|
|
export async function updateBillingPriceTierMultiplier(input: {
|
|
ruleId: string;
|
|
dimensionKey: string;
|
|
tierValue: string;
|
|
markupMultiplier: number;
|
|
}): Promise<BillingPriceRule | null> {
|
|
if (!Number.isFinite(input.markupMultiplier) || input.markupMultiplier < 1 || input.markupMultiplier > 1000) {
|
|
throw new BillingStoreError("上浮倍率必须在 1.00 至 1000.00 之间。", 400);
|
|
}
|
|
const existing = await getBillingPriceRule(input.ruleId);
|
|
if (!existing) return null;
|
|
const dimensions = existing.parameterDimensions || [];
|
|
const dimension = dimensions.find((item) => item.key === input.dimensionKey);
|
|
if (!dimension) throw new BillingStoreError("平台价格参数不存在。", 404);
|
|
const tierIndex = dimension.tiers.findIndex((item) => String(item.value) === input.tierValue);
|
|
if (tierIndex === -1) throw new BillingStoreError("平台价格档位不存在。", 404);
|
|
const nextDimensions = dimensions.map((item) => item.key !== input.dimensionKey ? item : {
|
|
...item,
|
|
tiers: item.tiers.map((tier, index) => index === tierIndex ? { ...tier, markupMultiplier: input.markupMultiplier } : tier)
|
|
});
|
|
return updateBillingPriceRule(input.ruleId, { parameterDimensions: nextDimensions });
|
|
}
|
|
|
|
export async function getOrganizationWallet(organizationId: string): Promise<OrganizationWallet> {
|
|
const supabase = getSupabaseAdmin();
|
|
if (supabase) {
|
|
const { data, error } = await supabase.from("billing_wallets").select("*").eq("organization_id", organizationId).maybeSingle();
|
|
if (error) throw new BillingStoreError(error.message, 500);
|
|
return data ? walletFromRow(data) : emptyWallet(organizationId);
|
|
}
|
|
const state = await readState();
|
|
return state.wallets.find((wallet) => wallet.organizationId === organizationId) || emptyWallet(organizationId);
|
|
}
|
|
|
|
export async function listOrganizationWallets(): Promise<OrganizationWallet[]> {
|
|
const supabase = getSupabaseAdmin();
|
|
if (supabase) {
|
|
const { data, error } = await supabase.from("billing_wallets").select("*").order("updated_at", { ascending: false });
|
|
if (error) throw new BillingStoreError(error.message, 500);
|
|
return (data || []).map(walletFromRow);
|
|
}
|
|
const state = await readState();
|
|
return [...state.wallets].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
|
|
}
|
|
|
|
export async function postWalletEntry(input: WalletEntryInput): Promise<{ entry: BillingLedgerEntry; wallet: OrganizationWallet }> {
|
|
const deltaFen = Math.trunc(input.deltaFen);
|
|
if (!Number.isFinite(deltaFen) || deltaFen === 0) throw new BillingStoreError("账务变动金额不能为 0。", 400);
|
|
if (!input.organizationId) throw new BillingStoreError("组织 ID 不能为空。", 400);
|
|
if (!input.idempotencyKey) throw new BillingStoreError("账务幂等键不能为空。", 400);
|
|
const accountId = effectiveLedgerAccountId(input);
|
|
const currency = input.currency || "CNY";
|
|
const metadata = input.metadata || {};
|
|
const supabase = getSupabaseAdmin();
|
|
if (supabase) {
|
|
const { data, error } = await supabase.rpc("billing_post_wallet_entry", {
|
|
p_ledger_id: createId("ledger"),
|
|
p_organization_id: input.organizationId,
|
|
p_account_id: accountId || null,
|
|
p_job_id: input.jobId || null,
|
|
p_kind: input.kind,
|
|
p_delta_fen: deltaFen,
|
|
p_currency: currency,
|
|
p_idempotency_key: input.idempotencyKey,
|
|
p_description: input.description,
|
|
p_metadata: metadata
|
|
});
|
|
if (error) {
|
|
if (/BILLING_INSUFFICIENT_BALANCE/i.test(error.message)) throw new InsufficientBalanceError();
|
|
throw new BillingStoreError(error.message, 500);
|
|
}
|
|
const row = firstRpcRow(data);
|
|
if (!row) throw new BillingStoreError("账务服务未返回流水结果。", 500);
|
|
return {
|
|
entry: ledgerFromRpcRow(row, input, accountId),
|
|
wallet: walletFromRpcRow(row, input.organizationId)
|
|
};
|
|
}
|
|
|
|
return mutateLocalState((state) => {
|
|
const existing = state.ledgerEntries.find((entry) => entry.idempotencyKey === input.idempotencyKey);
|
|
if (existing) {
|
|
const wallet = state.wallets.find((item) => item.organizationId === input.organizationId) || emptyWallet(input.organizationId);
|
|
return { entry: existing, wallet };
|
|
}
|
|
const wallet = state.wallets.find((item) => item.organizationId === input.organizationId) || emptyWallet(input.organizationId);
|
|
if (deltaFen < 0 && wallet.balanceFen < Math.abs(deltaFen)) throw new InsufficientBalanceError();
|
|
const now = new Date().toISOString();
|
|
const nextWallet: OrganizationWallet = {
|
|
...wallet,
|
|
balanceFen: wallet.balanceFen + deltaFen,
|
|
totalRechargedFen: wallet.totalRechargedFen + (input.kind === "recharge" && deltaFen > 0 ? deltaFen : 0),
|
|
totalChargedFen: wallet.totalChargedFen + (input.kind === "charge" && deltaFen < 0 ? Math.abs(deltaFen) : 0),
|
|
updatedAt: now
|
|
};
|
|
const entry: BillingLedgerEntry = {
|
|
id: createId("ledger"),
|
|
organizationId: input.organizationId,
|
|
accountId,
|
|
jobId: input.jobId,
|
|
kind: input.kind,
|
|
deltaFen,
|
|
balanceAfterFen: nextWallet.balanceFen,
|
|
currency,
|
|
idempotencyKey: input.idempotencyKey,
|
|
description: input.description,
|
|
metadata,
|
|
createdAt: now
|
|
};
|
|
const walletIndex = state.wallets.findIndex((item) => item.organizationId === input.organizationId);
|
|
if (walletIndex === -1) state.wallets.push(nextWallet);
|
|
else state.wallets[walletIndex] = nextWallet;
|
|
state.ledgerEntries.unshift(entry);
|
|
return { entry, wallet: nextWallet };
|
|
});
|
|
}
|
|
|
|
export async function listBillingLedgerEntries(filters: BillingLedgerFilters = {}): Promise<BillingLedgerEntry[]> {
|
|
const limit = Math.max(1, Math.min(filters.limit || 100, 500));
|
|
const supabase = getSupabaseAdmin();
|
|
if (supabase) {
|
|
let query = supabase.from("billing_ledger").select("*").order("created_at", { ascending: false }).limit(limit);
|
|
if (filters.organizationId) query = query.eq("organization_id", filters.organizationId);
|
|
if (filters.accountId) query = query.eq("account_id", filters.accountId);
|
|
if (filters.jobId) query = query.eq("job_id", filters.jobId);
|
|
if (filters.kind) query = query.eq("kind", filters.kind);
|
|
const { data, error } = await query;
|
|
if (error) throw new BillingStoreError(error.message, 500);
|
|
return (data || []).map(ledgerFromRow);
|
|
}
|
|
const state = await readState();
|
|
return state.ledgerEntries
|
|
.filter((entry) => !filters.organizationId || entry.organizationId === filters.organizationId)
|
|
.filter((entry) => !filters.accountId || entry.accountId === filters.accountId)
|
|
.filter((entry) => !filters.jobId || entry.jobId === filters.jobId)
|
|
.filter((entry) => !filters.kind || entry.kind === filters.kind)
|
|
.sort((left, right) => right.createdAt.localeCompare(left.createdAt))
|
|
.slice(0, limit);
|
|
}
|
|
|
|
async function readState(): Promise<BillingState> {
|
|
await ensureRuntimeDirs();
|
|
const path = join(dataDir(), STORE_FILE);
|
|
try {
|
|
return normalizeState(JSON.parse(await readFile(path, "utf8")));
|
|
} catch {
|
|
const state = normalizeState({});
|
|
await writeState(state);
|
|
return state;
|
|
}
|
|
}
|
|
|
|
async function writeState(state: BillingState): Promise<void> {
|
|
await ensureRuntimeDirs();
|
|
const path = join(dataDir(), STORE_FILE);
|
|
const temp = `${path}.${createId("tmp")}.tmp`;
|
|
await writeFile(temp, JSON.stringify(state, null, 2));
|
|
await rename(temp, path);
|
|
}
|
|
|
|
async function mutateLocalState<T>(mutator: (state: BillingState) => T): Promise<T> {
|
|
const run = localWriteQueue.then(async () => {
|
|
const state = await readState();
|
|
const result = mutator(state);
|
|
await writeState(state);
|
|
return result;
|
|
});
|
|
localWriteQueue = run.catch(() => undefined);
|
|
return run;
|
|
}
|
|
|
|
function normalizeState(raw: Partial<BillingState>): BillingState {
|
|
return {
|
|
priceRules: Array.isArray(raw.priceRules) ? raw.priceRules : [],
|
|
wallets: Array.isArray(raw.wallets) ? raw.wallets : [],
|
|
ledgerEntries: Array.isArray(raw.ledgerEntries) ? raw.ledgerEntries : []
|
|
};
|
|
}
|
|
|
|
function emptyWallet(organizationId: string): OrganizationWallet {
|
|
return {
|
|
organizationId,
|
|
balanceFen: 0,
|
|
totalRechargedFen: 0,
|
|
totalChargedFen: 0,
|
|
updatedAt: new Date(0).toISOString()
|
|
};
|
|
}
|
|
|
|
function getSupabaseAdmin(): SupabaseClient | null {
|
|
const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
|
|
const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
|
|
if (!url || !serviceRoleKey) return null;
|
|
return createClient(url, serviceRoleKey, { auth: { persistSession: false } });
|
|
}
|
|
|
|
function priceRuleToRow(rule: Partial<BillingPriceRule>) {
|
|
return {
|
|
id: rule.id,
|
|
provider: rule.provider,
|
|
capability: rule.capability,
|
|
req_key: rule.reqKey || null,
|
|
variant_key: rule.variantKey || null,
|
|
unit: rule.unit,
|
|
standard_unit_price_fen: rule.standardUnitPriceFen,
|
|
markup_multiplier: rule.markupMultiplier,
|
|
enabled: rule.enabled,
|
|
conditions: rule.conditions || {},
|
|
quantity_source: rule.quantitySource || null,
|
|
priority: rule.priority || 0,
|
|
note: rule.note || null,
|
|
source: rule.source || null,
|
|
parameter_dimensions: rule.parameterDimensions || [],
|
|
created_at: rule.createdAt,
|
|
updated_at: rule.updatedAt
|
|
};
|
|
}
|
|
|
|
function priceRuleFromRow(row: Record<string, unknown>): BillingPriceRule {
|
|
return {
|
|
id: String(row.id),
|
|
provider: row.provider as BillingPriceRule["provider"],
|
|
capability: row.capability as BillingPriceRule["capability"],
|
|
reqKey: optionalString(row.req_key),
|
|
variantKey: optionalString(row.variant_key),
|
|
unit: row.unit as BillingPriceRule["unit"],
|
|
standardUnitPriceFen: Number(row.standard_unit_price_fen || 0),
|
|
markupMultiplier: Number(row.markup_multiplier || 1),
|
|
enabled: row.enabled !== false,
|
|
conditions: isRecord(row.conditions) ? row.conditions as BillingRuleConditions : undefined,
|
|
quantitySource: row.quantity_source === "request" || row.quantity_source === "image_count" || row.quantity_source === "duration"
|
|
? row.quantity_source
|
|
: undefined,
|
|
priority: Number.isFinite(Number(row.priority)) ? Number(row.priority) : 0,
|
|
note: optionalString(row.note),
|
|
source: isRecord(row.source) ? row.source as BillingPriceRule["source"] : undefined,
|
|
parameterDimensions: Array.isArray(row.parameter_dimensions) ? row.parameter_dimensions as BillingParameterDimension[] : undefined,
|
|
createdAt: String(row.created_at),
|
|
updatedAt: String(row.updated_at)
|
|
};
|
|
}
|
|
|
|
function priceRuleMatchKey(rule: Pick<BillingPriceRule, "provider" | "capability" | "reqKey" | "variantKey" | "conditions">): string {
|
|
return [rule.provider, rule.capability, rule.reqKey || "", rule.variantKey || "", canonicalConditions(rule.conditions)].join("\u0000");
|
|
}
|
|
|
|
function canonicalConditions(conditions?: BillingRuleConditions): string {
|
|
if (!conditions || !isRecord(conditions)) return "{}";
|
|
const entries = Object.entries(conditions)
|
|
.sort(([left], [right]) => left.localeCompare(right))
|
|
.map(([key, value]) => [key, canonicalConditionValue(value)] as const);
|
|
return JSON.stringify(Object.fromEntries(entries));
|
|
}
|
|
|
|
function canonicalConditionValue(value: unknown): unknown {
|
|
if (Array.isArray(value)) return value.map(canonicalConditionValue).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
|
|
if (isRecord(value)) {
|
|
return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalConditionValue(item)]));
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function walletFromRow(row: Record<string, unknown>): OrganizationWallet {
|
|
return {
|
|
organizationId: String(row.organization_id),
|
|
balanceFen: Number(row.balance_fen || 0),
|
|
totalRechargedFen: Number(row.total_recharged_fen || 0),
|
|
totalChargedFen: Number(row.total_charged_fen || 0),
|
|
updatedAt: String(row.updated_at || new Date().toISOString())
|
|
};
|
|
}
|
|
|
|
function walletFromRpcRow(row: Record<string, unknown>, organizationId: string): OrganizationWallet {
|
|
return {
|
|
organizationId,
|
|
balanceFen: Number(row.balance_fen || row.balance_after_fen || 0),
|
|
totalRechargedFen: Number(row.total_recharged_fen || 0),
|
|
totalChargedFen: Number(row.total_charged_fen || 0),
|
|
updatedAt: String(row.updated_at || row.created_at || new Date().toISOString())
|
|
};
|
|
}
|
|
|
|
function ledgerFromRow(row: Record<string, unknown>): BillingLedgerEntry {
|
|
return {
|
|
id: String(row.id),
|
|
organizationId: String(row.organization_id),
|
|
accountId: optionalString(row.account_id),
|
|
jobId: optionalString(row.job_id),
|
|
kind: row.kind as BillingLedgerKind,
|
|
deltaFen: Number(row.delta_fen || 0),
|
|
balanceAfterFen: Number(row.balance_after_fen || 0),
|
|
currency: row.currency === "CNY" ? "CNY" : "CNY",
|
|
idempotencyKey: String(row.idempotency_key),
|
|
description: String(row.description || ""),
|
|
metadata: isRecord(row.metadata) ? row.metadata : {},
|
|
createdAt: String(row.created_at)
|
|
};
|
|
}
|
|
|
|
function ledgerFromRpcRow(row: Record<string, unknown>, input: WalletEntryInput, accountId?: string): BillingLedgerEntry {
|
|
return {
|
|
id: String(row.ledger_id || row.id),
|
|
organizationId: input.organizationId,
|
|
accountId,
|
|
jobId: input.jobId,
|
|
kind: input.kind,
|
|
deltaFen: Number(row.delta_fen ?? input.deltaFen),
|
|
balanceAfterFen: Number(row.balance_after_fen || 0),
|
|
currency: input.currency || "CNY",
|
|
idempotencyKey: input.idempotencyKey,
|
|
description: input.description,
|
|
metadata: input.metadata || {},
|
|
createdAt: String(row.created_at || new Date().toISOString())
|
|
};
|
|
}
|
|
|
|
function effectiveLedgerAccountId(input: Pick<WalletEntryInput, "kind" | "accountId">): string | undefined {
|
|
if (input.kind === "recharge" || input.kind === "adjustment") return undefined;
|
|
return optionalString(input.accountId);
|
|
}
|
|
|
|
function firstRpcRow(value: unknown): Record<string, unknown> | null {
|
|
if (Array.isArray(value)) return isRecord(value[0]) ? value[0] : null;
|
|
return isRecord(value) ? value : null;
|
|
}
|
|
|
|
function isRecord(value: unknown): value is Record<string, unknown> {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
}
|
|
|
|
function optionalString(value: unknown): string | undefined {
|
|
if (typeof value !== "string") return undefined;
|
|
const trimmed = value.trim();
|
|
return trimmed || undefined;
|
|
}
|
|
|
|
function normalizeBillingStoreErrorMessage(message: string): string {
|
|
if (/(billing_|billing_post_wallet_entry|variant_key|standard_unit_price_fen|markup_multiplier|source)/i.test(message)
|
|
&& /(schema cache|relation .* does not exist|table .* does not exist|column .* does not exist|could not find|function .* does not exist)/i.test(message)) {
|
|
return "计费数据库尚未初始化或未完成升级，请在 Supabase SQL Editor 执行仓库中的 supabase/schema.sql 后重启服务。";
|
|
}
|
|
return message;
|
|
}
|