681 lines
22 KiB
TypeScript
681 lines
22 KiB
TypeScript
import type { Db } from "./index.ts";
|
|
import {
|
|
apiKeys,
|
|
auditLogs,
|
|
engineStatus,
|
|
members,
|
|
payments,
|
|
qpuHistory,
|
|
sessions,
|
|
usageLogs,
|
|
users,
|
|
type ApiKeyRow,
|
|
type AuditLogRow,
|
|
type EngineStatusRow,
|
|
type MemberRow,
|
|
type PaymentRow,
|
|
type SessionRow,
|
|
type UsageLogRow,
|
|
type UserRow,
|
|
} from "./schema.ts";
|
|
import { and, asc, count, desc, eq, gt, gte, isNull, lt, ne, or, sql } from "drizzle-orm";
|
|
|
|
export interface SessionUser {
|
|
user_id: number;
|
|
username: string;
|
|
expires_at: Date;
|
|
}
|
|
|
|
export interface KeyListRow extends ApiKeyRow {
|
|
member_name: string | null;
|
|
}
|
|
|
|
/**
|
|
* 仓储层（R14）：数据访问只出现在 packages/db。
|
|
* apps/server 不 import drizzle-orm / postgres 驱动。
|
|
*/
|
|
export function createRepos(db: Db) {
|
|
return {
|
|
users: {
|
|
async countAll(): Promise<number> {
|
|
const rows = await db.select({ id: users.id }).from(users).limit(1);
|
|
return rows[0] ? 1 : 0;
|
|
},
|
|
async findByUsername(username: string): Promise<UserRow | null> {
|
|
const rows = await db
|
|
.select()
|
|
.from(users)
|
|
.where(eq(users.username, username))
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async findById(id: number): Promise<UserRow | null> {
|
|
const rows = await db.select().from(users).where(eq(users.id, id)).limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async insert(username: string, password_hash: string): Promise<UserRow> {
|
|
const [row] = await db
|
|
.insert(users)
|
|
.values({ username, password_hash })
|
|
.returning();
|
|
return row!;
|
|
},
|
|
async updatePassword(id: number, password_hash: string): Promise<void> {
|
|
await db.update(users).set({ password_hash }).where(eq(users.id, id));
|
|
},
|
|
},
|
|
|
|
sessions: {
|
|
async findValid(
|
|
token_hash: string,
|
|
now: Date,
|
|
): Promise<SessionUser | null> {
|
|
const rows = await db
|
|
.select({
|
|
user_id: sessions.user_id,
|
|
username: users.username,
|
|
expires_at: sessions.expires_at,
|
|
})
|
|
.from(sessions)
|
|
.innerJoin(users, eq(sessions.user_id, users.id))
|
|
.where(
|
|
and(eq(sessions.token_hash, token_hash), gt(sessions.expires_at, now)),
|
|
)
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async insert(
|
|
user_id: number,
|
|
token_hash: string,
|
|
expires_at: Date,
|
|
): Promise<SessionRow> {
|
|
const [row] = await db
|
|
.insert(sessions)
|
|
.values({ user_id, token_hash, expires_at })
|
|
.returning();
|
|
return row!;
|
|
},
|
|
async deleteByTokenHash(token_hash: string): Promise<void> {
|
|
await db.delete(sessions).where(eq(sessions.token_hash, token_hash));
|
|
},
|
|
async listByUser(user_id: number) {
|
|
return db
|
|
.select({ id: sessions.id, token_hash: sessions.token_hash })
|
|
.from(sessions)
|
|
.where(eq(sessions.user_id, user_id));
|
|
},
|
|
async deleteById(id: number): Promise<void> {
|
|
await db.delete(sessions).where(eq(sessions.id, id));
|
|
},
|
|
},
|
|
|
|
keys: {
|
|
async listAll(filter?: {
|
|
member_id?: number | "unassigned";
|
|
status?: string;
|
|
}): Promise<KeyListRow[]> {
|
|
const conds = [];
|
|
if (filter?.member_id === "unassigned") {
|
|
conds.push(sql`${apiKeys.member_id} is null`);
|
|
} else if (typeof filter?.member_id === "number") {
|
|
conds.push(eq(apiKeys.member_id, filter.member_id));
|
|
}
|
|
if (filter?.status) {
|
|
conds.push(eq(apiKeys.status, filter.status));
|
|
}
|
|
const base = db
|
|
.select({
|
|
id: apiKeys.id,
|
|
key_hash: apiKeys.key_hash,
|
|
key_ciphertext: apiKeys.key_ciphertext,
|
|
status: apiKeys.status,
|
|
member_id: apiKeys.member_id,
|
|
registered_at: apiKeys.registered_at,
|
|
log_synced_at: apiKeys.log_synced_at,
|
|
usage_synced_at: apiKeys.usage_synced_at,
|
|
token_name: apiKeys.token_name,
|
|
total_granted: apiKeys.total_granted,
|
|
total_used: apiKeys.total_used,
|
|
total_available: apiKeys.total_available,
|
|
unlimited_quota: apiKeys.unlimited_quota,
|
|
model_limits: apiKeys.model_limits,
|
|
model_limits_enabled: apiKeys.model_limits_enabled,
|
|
expires_at: apiKeys.expires_at,
|
|
member_name: members.name,
|
|
})
|
|
.from(apiKeys)
|
|
.leftJoin(members, eq(apiKeys.member_id, members.id));
|
|
if (conds.length > 0) {
|
|
return base.where(and(...conds));
|
|
}
|
|
return base;
|
|
},
|
|
async listActive() {
|
|
return db
|
|
.select({
|
|
id: apiKeys.id,
|
|
key_hash: apiKeys.key_hash,
|
|
key_ciphertext: apiKeys.key_ciphertext,
|
|
status: apiKeys.status,
|
|
member_id: apiKeys.member_id,
|
|
token_name: apiKeys.token_name,
|
|
})
|
|
.from(apiKeys)
|
|
.where(eq(apiKeys.status, "active"))
|
|
.orderBy(asc(apiKeys.id));
|
|
},
|
|
async insertLog(values: {
|
|
api_key_id: number;
|
|
dedupe_key: string;
|
|
billing_source: string | null;
|
|
subscription_id: number | null;
|
|
user_id: number;
|
|
created_at: Date;
|
|
type: number;
|
|
content: string;
|
|
username: string;
|
|
token_name: string;
|
|
model_name: string;
|
|
quota: number;
|
|
prompt_tokens: number;
|
|
completion_tokens: number;
|
|
use_time: number;
|
|
is_stream: boolean;
|
|
channel: number;
|
|
channel_name: string;
|
|
token_id: number;
|
|
group_name: string;
|
|
ip: string;
|
|
request_id: string;
|
|
upstream_request_id: string | null;
|
|
other: unknown;
|
|
}): Promise<boolean> {
|
|
const before = await db
|
|
.select({ n: count() })
|
|
.from(usageLogs)
|
|
.where(eq(usageLogs.dedupe_key, values.dedupe_key));
|
|
if ((before[0]?.n ?? 0) > 0) return false;
|
|
await db.insert(usageLogs).values(values).onConflictDoNothing();
|
|
return true;
|
|
},
|
|
async findById(id: number): Promise<ApiKeyRow | null> {
|
|
const rows = await db
|
|
.select()
|
|
.from(apiKeys)
|
|
.where(eq(apiKeys.id, id))
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async findByHash(key_hash: string): Promise<{ id: number } | null> {
|
|
const rows = await db
|
|
.select({ id: apiKeys.id })
|
|
.from(apiKeys)
|
|
.where(eq(apiKeys.key_hash, key_hash))
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async insert(values: {
|
|
key_hash: string;
|
|
key_ciphertext: Uint8Array;
|
|
member_id: number | null;
|
|
token_name?: string;
|
|
}): Promise<ApiKeyRow> {
|
|
const [row] = await db
|
|
.insert(apiKeys)
|
|
.values({
|
|
key_hash: values.key_hash,
|
|
key_ciphertext: values.key_ciphertext,
|
|
member_id: values.member_id,
|
|
token_name: values.token_name ?? "",
|
|
})
|
|
.returning();
|
|
return row!;
|
|
},
|
|
async update(
|
|
id: number,
|
|
patch: Partial<typeof apiKeys.$inferInsert>,
|
|
): Promise<ApiKeyRow> {
|
|
const [row] = await db
|
|
.update(apiKeys)
|
|
.set(patch)
|
|
.where(eq(apiKeys.id, id))
|
|
.returning();
|
|
return row!;
|
|
},
|
|
},
|
|
|
|
members: {
|
|
async listAll(): Promise<MemberRow[]> {
|
|
return db.select().from(members);
|
|
},
|
|
async findById(id: number): Promise<MemberRow | null> {
|
|
const rows = await db
|
|
.select()
|
|
.from(members)
|
|
.where(eq(members.id, id))
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async findByName(name: string): Promise<{ id: number } | null> {
|
|
const rows = await db
|
|
.select({ id: members.id })
|
|
.from(members)
|
|
.where(eq(members.name, name))
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async findByTokenHash(token_hash: string): Promise<{
|
|
id: number;
|
|
status: string;
|
|
} | null> {
|
|
const rows = await db
|
|
.select({ id: members.id, status: members.status })
|
|
.from(members)
|
|
.where(eq(members.token_hash, token_hash))
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async insert(values: {
|
|
name: string;
|
|
remark: string;
|
|
token_hash: string;
|
|
token_issued_at: Date;
|
|
}): Promise<MemberRow> {
|
|
const [row] = await db.insert(members).values(values).returning();
|
|
return row!;
|
|
},
|
|
async updateStatus(id: number, status: string): Promise<MemberRow> {
|
|
const [row] = await db
|
|
.update(members)
|
|
.set({ status })
|
|
.where(eq(members.id, id))
|
|
.returning();
|
|
return row!;
|
|
},
|
|
async reissueToken(
|
|
id: number,
|
|
token_hash: string,
|
|
token_issued_at: Date,
|
|
): Promise<void> {
|
|
await db
|
|
.update(members)
|
|
.set({ token_hash, token_issued_at })
|
|
.where(eq(members.id, id));
|
|
},
|
|
async countKeys(member_id: number): Promise<number> {
|
|
const rows = await db
|
|
.select({ n: count() })
|
|
.from(apiKeys)
|
|
.where(eq(apiKeys.member_id, member_id));
|
|
return rows[0]?.n ?? 0;
|
|
},
|
|
},
|
|
|
|
audit: {
|
|
async insert(values: {
|
|
operator: string | null;
|
|
domain: string;
|
|
action: string;
|
|
summary: string;
|
|
}): Promise<AuditLogRow> {
|
|
const [row] = await db.insert(auditLogs).values(values).returning();
|
|
return row!;
|
|
},
|
|
async listPage(params: {
|
|
domain?: string;
|
|
from?: Date;
|
|
to?: Date;
|
|
page: number;
|
|
page_size: number;
|
|
}): Promise<{ rows: AuditLogRow[]; total: number }> {
|
|
const conds = params.domain ? [eq(auditLogs.domain, params.domain)] : [];
|
|
if (params.from) conds.push(gte(auditLogs.created_at, params.from));
|
|
if (params.to) conds.push(lt(auditLogs.created_at, params.to));
|
|
const totalRows = await db
|
|
.select({ n: count() })
|
|
.from(auditLogs)
|
|
.where(conds.length ? and(...conds) : undefined);
|
|
const total = totalRows[0]?.n ?? 0;
|
|
const rows = await db
|
|
.select()
|
|
.from(auditLogs)
|
|
.where(conds.length ? and(...conds) : undefined)
|
|
.orderBy(desc(auditLogs.created_at), desc(auditLogs.id))
|
|
.limit(params.page_size)
|
|
.offset((params.page - 1) * params.page_size);
|
|
return { rows, total };
|
|
},
|
|
},
|
|
|
|
engine: {
|
|
async upsertSnapshot(values: {
|
|
running: boolean;
|
|
sync_interval_ms: number;
|
|
last_round: unknown;
|
|
}): Promise<EngineStatusRow> {
|
|
const [row] = await db
|
|
.insert(engineStatus)
|
|
.values({
|
|
id: 1,
|
|
running: values.running,
|
|
sync_interval_ms: values.sync_interval_ms,
|
|
last_round: values.last_round,
|
|
updated_at: new Date(),
|
|
})
|
|
.onConflictDoUpdate({
|
|
target: engineStatus.id,
|
|
set: {
|
|
running: values.running,
|
|
sync_interval_ms: values.sync_interval_ms,
|
|
last_round: values.last_round,
|
|
updated_at: new Date(),
|
|
},
|
|
})
|
|
.returning();
|
|
return row!;
|
|
},
|
|
async getSnapshot(): Promise<EngineStatusRow | null> {
|
|
const rows = await db
|
|
.select()
|
|
.from(engineStatus)
|
|
.where(eq(engineStatus.id, 1))
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
},
|
|
|
|
payments: {
|
|
async listAll(): Promise<PaymentRow[]> {
|
|
return db.select().from(payments).orderBy(desc(payments.paid_at));
|
|
},
|
|
async findById(id: number): Promise<PaymentRow | null> {
|
|
const rows = await db
|
|
.select()
|
|
.from(payments)
|
|
.where(eq(payments.id, id))
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async insert(values: {
|
|
kind: string;
|
|
paid_at: Date;
|
|
paid_amount: number;
|
|
remark: string;
|
|
period_start: Date | null;
|
|
period_end: Date | null;
|
|
subscription_id: number | null;
|
|
quota_granted: number | null;
|
|
}): Promise<PaymentRow> {
|
|
const [row] = await db.insert(payments).values(values).returning();
|
|
return row!;
|
|
},
|
|
async update(id: number, patch: Partial<typeof payments.$inferInsert>) {
|
|
const [row] = await db
|
|
.update(payments)
|
|
.set(patch)
|
|
.where(eq(payments.id, id))
|
|
.returning();
|
|
return row!;
|
|
},
|
|
async remove(id: number): Promise<void> {
|
|
await db.delete(payments).where(eq(payments.id, id));
|
|
},
|
|
},
|
|
|
|
qpu: {
|
|
async listTimeline(): Promise<
|
|
Array<{ qpu: number; effective_from: Date }>
|
|
> {
|
|
return db
|
|
.select({
|
|
qpu: qpuHistory.qpu,
|
|
effective_from: qpuHistory.effective_from,
|
|
})
|
|
.from(qpuHistory)
|
|
.orderBy(asc(qpuHistory.effective_from));
|
|
},
|
|
async latest(): Promise<{ qpu: number; effective_from: Date } | null> {
|
|
const rows = await db
|
|
.select({
|
|
qpu: qpuHistory.qpu,
|
|
effective_from: qpuHistory.effective_from,
|
|
})
|
|
.from(qpuHistory)
|
|
.orderBy(desc(qpuHistory.effective_from))
|
|
.limit(1);
|
|
return rows[0] ?? null;
|
|
},
|
|
async insertChange(qpu: number, effective_from: Date): Promise<void> {
|
|
await db.insert(qpuHistory).values({ qpu, effective_from });
|
|
},
|
|
},
|
|
|
|
logs: {
|
|
/** 明细分页（时间范围左闭右开） */
|
|
async listPage(params: {
|
|
from: Date;
|
|
to: Date;
|
|
api_key_id?: number;
|
|
member_id?: number | "unassigned";
|
|
billing_source?: string | "none";
|
|
subscription_id?: number;
|
|
type?: number | "error";
|
|
page: number;
|
|
page_size: number;
|
|
}): Promise<{ rows: Array<UsageLogRow & { token_name: string }>; total: number }> {
|
|
const conds = [
|
|
gte(usageLogs.created_at, params.from),
|
|
lt(usageLogs.created_at, params.to),
|
|
];
|
|
if (params.api_key_id != null) {
|
|
conds.push(eq(usageLogs.api_key_id, params.api_key_id));
|
|
}
|
|
if (params.billing_source === "none") {
|
|
conds.push(isNull(usageLogs.billing_source));
|
|
} else if (params.billing_source) {
|
|
conds.push(eq(usageLogs.billing_source, params.billing_source));
|
|
}
|
|
if (params.subscription_id != null) {
|
|
conds.push(eq(usageLogs.subscription_id, params.subscription_id));
|
|
}
|
|
if (params.type === "error") {
|
|
conds.push(ne(usageLogs.type, 2));
|
|
} else if (typeof params.type === "number") {
|
|
conds.push(eq(usageLogs.type, params.type));
|
|
}
|
|
if (params.member_id === "unassigned") {
|
|
conds.push(isNull(apiKeys.member_id));
|
|
} else if (params.member_id != null) {
|
|
conds.push(eq(apiKeys.member_id, params.member_id));
|
|
}
|
|
|
|
const totalRows = await db
|
|
.select({ n: count() })
|
|
.from(usageLogs)
|
|
.leftJoin(apiKeys, eq(usageLogs.api_key_id, apiKeys.id))
|
|
.where(and(...conds));
|
|
const total = totalRows[0]?.n ?? 0;
|
|
|
|
const offset = (params.page - 1) * params.page_size;
|
|
const rows = await db
|
|
.select({
|
|
id: usageLogs.id,
|
|
api_key_id: usageLogs.api_key_id,
|
|
dedupe_key: usageLogs.dedupe_key,
|
|
billing_source: usageLogs.billing_source,
|
|
subscription_id: usageLogs.subscription_id,
|
|
user_id: usageLogs.user_id,
|
|
created_at: usageLogs.created_at,
|
|
type: usageLogs.type,
|
|
content: usageLogs.content,
|
|
username: usageLogs.username,
|
|
token_name: apiKeys.token_name,
|
|
model_name: usageLogs.model_name,
|
|
quota: usageLogs.quota,
|
|
prompt_tokens: usageLogs.prompt_tokens,
|
|
completion_tokens: usageLogs.completion_tokens,
|
|
use_time: usageLogs.use_time,
|
|
is_stream: usageLogs.is_stream,
|
|
channel: usageLogs.channel,
|
|
channel_name: usageLogs.channel_name,
|
|
token_id: usageLogs.token_id,
|
|
group_name: usageLogs.group_name,
|
|
ip: usageLogs.ip,
|
|
request_id: usageLogs.request_id,
|
|
upstream_request_id: usageLogs.upstream_request_id,
|
|
other: usageLogs.other,
|
|
})
|
|
.from(usageLogs)
|
|
.leftJoin(apiKeys, eq(usageLogs.api_key_id, apiKeys.id))
|
|
.where(and(...conds))
|
|
.orderBy(desc(usageLogs.created_at), desc(usageLogs.id))
|
|
.limit(params.page_size)
|
|
.offset(offset);
|
|
|
|
return {
|
|
rows: rows.map((r) => ({
|
|
...r,
|
|
token_name: r.token_name ?? "",
|
|
})) as Array<UsageLogRow & { token_name: string }>,
|
|
total,
|
|
};
|
|
},
|
|
|
|
/** 总览聚合用：type=2、按维字段 */
|
|
async listForAggregate(from: Date, to: Date, type = 2) {
|
|
return db
|
|
.select({
|
|
api_key_id: usageLogs.api_key_id,
|
|
member_id: apiKeys.member_id,
|
|
billing_source: usageLogs.billing_source,
|
|
subscription_id: usageLogs.subscription_id,
|
|
quota: usageLogs.quota,
|
|
created_at: usageLogs.created_at,
|
|
token_name: apiKeys.token_name,
|
|
status: apiKeys.status,
|
|
log_synced_at: apiKeys.log_synced_at,
|
|
member_name: members.name,
|
|
})
|
|
.from(usageLogs)
|
|
.leftJoin(apiKeys, eq(usageLogs.api_key_id, apiKeys.id))
|
|
.leftJoin(members, eq(apiKeys.member_id, members.id))
|
|
.where(
|
|
and(
|
|
gte(usageLogs.created_at, from),
|
|
lt(usageLogs.created_at, to),
|
|
eq(usageLogs.type, type),
|
|
),
|
|
);
|
|
},
|
|
|
|
/** 成员视图聚合（名下 key、type=2） */
|
|
async listMemberForAggregate(
|
|
member_id: number,
|
|
from: Date,
|
|
to: Date,
|
|
type = 2,
|
|
) {
|
|
return db
|
|
.select({
|
|
api_key_id: usageLogs.api_key_id,
|
|
billing_source: usageLogs.billing_source,
|
|
subscription_id: usageLogs.subscription_id,
|
|
quota: usageLogs.quota,
|
|
created_at: usageLogs.created_at,
|
|
token_name: apiKeys.token_name,
|
|
log_synced_at: apiKeys.log_synced_at,
|
|
})
|
|
.from(usageLogs)
|
|
.innerJoin(apiKeys, eq(usageLogs.api_key_id, apiKeys.id))
|
|
.where(
|
|
and(
|
|
eq(apiKeys.member_id, member_id),
|
|
gte(usageLogs.created_at, from),
|
|
lt(usageLogs.created_at, to),
|
|
eq(usageLogs.type, type),
|
|
),
|
|
);
|
|
},
|
|
|
|
/** 成员视图明细分页（恒 type=2） */
|
|
async listMemberPage(params: {
|
|
member_id: number;
|
|
from: Date;
|
|
to: Date;
|
|
page: number;
|
|
page_size: number;
|
|
}) {
|
|
const conds = [
|
|
eq(apiKeys.member_id, params.member_id),
|
|
gte(usageLogs.created_at, params.from),
|
|
lt(usageLogs.created_at, params.to),
|
|
eq(usageLogs.type, 2),
|
|
];
|
|
const totalRows = await db
|
|
.select({ n: count() })
|
|
.from(usageLogs)
|
|
.innerJoin(apiKeys, eq(usageLogs.api_key_id, apiKeys.id))
|
|
.where(and(...conds));
|
|
const total = totalRows[0]?.n ?? 0;
|
|
const rows = await db
|
|
.select({
|
|
id: usageLogs.id,
|
|
api_key_id: usageLogs.api_key_id,
|
|
created_at: usageLogs.created_at,
|
|
token_name: apiKeys.token_name,
|
|
model_name: usageLogs.model_name,
|
|
type: usageLogs.type,
|
|
content: usageLogs.content,
|
|
quota: usageLogs.quota,
|
|
prompt_tokens: usageLogs.prompt_tokens,
|
|
completion_tokens: usageLogs.completion_tokens,
|
|
use_time: usageLogs.use_time,
|
|
is_stream: usageLogs.is_stream,
|
|
billing_source: usageLogs.billing_source,
|
|
subscription_id: usageLogs.subscription_id,
|
|
log_synced_at: apiKeys.log_synced_at,
|
|
})
|
|
.from(usageLogs)
|
|
.innerJoin(apiKeys, eq(usageLogs.api_key_id, apiKeys.id))
|
|
.where(and(...conds))
|
|
.orderBy(desc(usageLogs.created_at), desc(usageLogs.id))
|
|
.limit(params.page_size)
|
|
.offset((params.page - 1) * params.page_size);
|
|
return { rows, total };
|
|
},
|
|
},
|
|
|
|
keysExtra: {
|
|
/** 全池数据截止 = 仍会同步的 key 中最慢 log_synced_at（停用 key 不计） */
|
|
async slowestLogSyncedAt(): Promise<Date | null> {
|
|
const rows = await db
|
|
.select({ t: sql<string | null>`min(${apiKeys.log_synced_at})::text` })
|
|
.from(apiKeys)
|
|
.where(
|
|
and(
|
|
eq(apiKeys.status, "active"),
|
|
sql`${apiKeys.log_synced_at} is not null`,
|
|
),
|
|
);
|
|
const raw = rows[0]?.t;
|
|
if (!raw) return null;
|
|
const d = new Date(raw);
|
|
return Number.isNaN(d.getTime()) ? null : d;
|
|
},
|
|
async listIdsWithCutoff() {
|
|
return db
|
|
.select({
|
|
id: apiKeys.id,
|
|
member_id: apiKeys.member_id,
|
|
token_name: apiKeys.token_name,
|
|
status: apiKeys.status,
|
|
log_synced_at: apiKeys.log_synced_at,
|
|
})
|
|
.from(apiKeys);
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
export type Repos = ReturnType<typeof createRepos>;
|