262 lines
9.1 KiB
TypeScript
262 lines
9.1 KiB
TypeScript
import { z } from "zod";
|
|
import { EntityBase, Id, JsonObject, NonNegInt, SERVER_MANAGED, Timestamp } from "./common";
|
|
|
|
// 来源域:站点、站点账号、Feed、站点资源、观察(REQ §4)
|
|
// 含 passkey 的 Feed URL 只以 urlSecretRef 保存,对外只给脱敏的 urlDisplay。
|
|
|
|
export const SiteAdapter = z.enum(["nexusphp", "mteam_api", "generic_rss"]);
|
|
export type SiteAdapter = z.infer<typeof SiteAdapter>;
|
|
export const SiteHealth = z.enum(["unknown", "healthy", "degraded", "failing", "disabled"]);
|
|
export type SiteHealth = z.infer<typeof SiteHealth>;
|
|
export const CircuitState = z.enum(["closed", "open", "half_open"]);
|
|
export type CircuitState = z.infer<typeof CircuitState>;
|
|
|
|
/** 站点级限流(快照、实时搜索、浏览器共享) */
|
|
export const SiteRateLimit = z.object({
|
|
requestsPerMinute: z.number().int().positive().optional(),
|
|
minIntervalMs: z.number().int().nonnegative().optional(),
|
|
concurrency: z.number().int().positive().optional(),
|
|
});
|
|
export type SiteRateLimit = z.infer<typeof SiteRateLimit>;
|
|
|
|
export const Site = EntityBase.extend({
|
|
key: z.string().regex(/^[a-z][a-z0-9_-]*$/),
|
|
name: z.string().min(1),
|
|
adapter: SiteAdapter,
|
|
baseUrl: z.url(),
|
|
enabled: z.boolean(),
|
|
rateLimit: SiteRateLimit,
|
|
config: JsonObject,
|
|
healthStatus: SiteHealth,
|
|
circuitState: CircuitState,
|
|
circuitOpenUntil: Timestamp.nullable(),
|
|
snapshotEnabled: z.boolean(),
|
|
snapshotIntervalSec: z.number().int().positive().nullable(),
|
|
lastSnapshotAt: Timestamp.nullable(),
|
|
snapshotCursor: JsonObject,
|
|
});
|
|
export type Site = z.infer<typeof Site>;
|
|
export const SiteCreate = Site.pick({
|
|
key: true,
|
|
name: true,
|
|
adapter: true,
|
|
baseUrl: true,
|
|
enabled: true,
|
|
rateLimit: true,
|
|
config: true,
|
|
snapshotEnabled: true,
|
|
snapshotIntervalSec: true,
|
|
}).partial({ enabled: true, rateLimit: true, config: true, snapshotEnabled: true, snapshotIntervalSec: true });
|
|
export type SiteCreate = z.infer<typeof SiteCreate>;
|
|
export const SiteUpdate = SiteCreate.omit({ key: true }).partial();
|
|
export type SiteUpdate = z.infer<typeof SiteUpdate>;
|
|
|
|
export const SiteAuthKind = z.enum(["cookie", "passkey", "api_key", "password"]);
|
|
export type SiteAuthKind = z.infer<typeof SiteAuthKind>;
|
|
export const SiteAccountStatus = z.enum(["unknown", "active", "invalid", "expired"]);
|
|
export type SiteAccountStatus = z.infer<typeof SiteAccountStatus>;
|
|
|
|
export const SiteAccount = EntityBase.extend({
|
|
siteId: Id,
|
|
label: z.string().min(1),
|
|
authKind: SiteAuthKind,
|
|
secretRef: Id.nullable(),
|
|
enabled: z.boolean(),
|
|
status: SiteAccountStatus,
|
|
lastVerifiedAt: Timestamp.nullable(),
|
|
userInfo: JsonObject,
|
|
});
|
|
export type SiteAccount = z.infer<typeof SiteAccount>;
|
|
export const SiteAccountCreate = SiteAccount.pick({ siteId: true, label: true, authKind: true, enabled: true })
|
|
.partial({ enabled: true })
|
|
.extend({ credential: z.string().min(1).max(16384) });
|
|
export type SiteAccountCreate = z.infer<typeof SiteAccountCreate>;
|
|
export const SiteAccountUpdate = SiteAccountCreate.omit({ siteId: true }).partial();
|
|
export type SiteAccountUpdate = z.infer<typeof SiteAccountUpdate>;
|
|
|
|
export const FeedPurpose = z.enum(["movie", "series", "variety", "promotion", "search", "generic"]);
|
|
export type FeedPurpose = z.infer<typeof FeedPurpose>;
|
|
export const FeedKind = z.enum(["rss", "atom", "list", "query"]);
|
|
export type FeedKind = z.infer<typeof FeedKind>;
|
|
export const FeedHealth = z.enum(["unknown", "healthy", "degraded", "failing", "circuit_open", "disabled"]);
|
|
export type FeedHealth = z.infer<typeof FeedHealth>;
|
|
|
|
export const FeedSource = EntityBase.extend({
|
|
siteId: Id.nullable(),
|
|
siteAccountId: Id.nullable(),
|
|
name: z.string().min(1),
|
|
purpose: FeedPurpose,
|
|
kind: FeedKind,
|
|
urlSecretRef: Id.nullable(),
|
|
/** 脱敏 URL(passkey 等参数替换为 [REDACTED]) */
|
|
urlDisplay: z.string(),
|
|
parserVersion: z.string(),
|
|
enabled: z.boolean(),
|
|
pollIntervalSec: z.number().int().min(60),
|
|
filter: JsonObject,
|
|
cursor: JsonObject,
|
|
etag: z.string().nullable(),
|
|
lastModified: z.string().nullable(),
|
|
lastFetchAt: Timestamp.nullable(),
|
|
lastSuccessAt: Timestamp.nullable(),
|
|
nextFetchAt: Timestamp.nullable(),
|
|
consecutiveFailures: NonNegInt,
|
|
backoffUntil: Timestamp.nullable(),
|
|
healthStatus: FeedHealth,
|
|
lastError: JsonObject.nullable(),
|
|
});
|
|
export type FeedSource = z.infer<typeof FeedSource>;
|
|
/** url 为只写明文(可能含 passkey),服务端加密存为 secret 并生成 urlDisplay */
|
|
export const FeedSourceCreate = FeedSource.pick({
|
|
siteId: true,
|
|
siteAccountId: true,
|
|
name: true,
|
|
purpose: true,
|
|
kind: true,
|
|
enabled: true,
|
|
pollIntervalSec: true,
|
|
filter: true,
|
|
})
|
|
.partial({
|
|
siteId: true,
|
|
siteAccountId: true,
|
|
purpose: true,
|
|
kind: true,
|
|
enabled: true,
|
|
pollIntervalSec: true,
|
|
filter: true,
|
|
})
|
|
.extend({ url: z.url() });
|
|
export type FeedSourceCreate = z.infer<typeof FeedSourceCreate>;
|
|
export const FeedSourceUpdate = FeedSourceCreate.partial();
|
|
export type FeedSourceUpdate = z.infer<typeof FeedSourceUpdate>;
|
|
|
|
export const ResolutionStatus = z.enum(["unresolved", "resolved", "ambiguous", "unidentifiable", "rejected"]);
|
|
export type ResolutionStatus = z.infer<typeof ResolutionStatus>;
|
|
export const ReleaseAvailability = z.enum(["active", "site_disabled", "expired", "unknown"]);
|
|
export type ReleaseAvailability = z.infer<typeof ReleaseAvailability>;
|
|
|
|
/** 促销状态必须带观察时间与过期时间,下单前按策略复核(REQ §4.3) */
|
|
export const Promotion = z.object({
|
|
kind: z.string().optional(),
|
|
observedAt: Timestamp.optional(),
|
|
expiresAt: Timestamp.nullable().optional(),
|
|
raw: z.unknown().optional(),
|
|
});
|
|
export type Promotion = z.infer<typeof Promotion>;
|
|
|
|
export const TorrentFileEntry = z.object({
|
|
path: z.string(),
|
|
size: NonNegInt,
|
|
});
|
|
export type TorrentFileEntry = z.infer<typeof TorrentFileEntry>;
|
|
|
|
export const SourceRelease = EntityBase.extend({
|
|
siteId: Id,
|
|
siteReleaseId: z.string().min(1),
|
|
title: z.string(),
|
|
subtitle: z.string().nullable(),
|
|
categoryRaw: z.string().nullable(),
|
|
tagsRaw: z.array(z.string()),
|
|
sizeBytes: NonNegInt.nullable(),
|
|
infohashV1: z.string().nullable(),
|
|
infohashV2: z.string().nullable(),
|
|
fileList: z.array(TorrentFileEntry).nullable(),
|
|
promotion: Promotion,
|
|
promotionExpiresAt: Timestamp.nullable(),
|
|
seeders: z.number().int().nullable(),
|
|
leechers: z.number().int().nullable(),
|
|
/** 站点发布时间;区别于 firstSeenAt(本系统首次发现) */
|
|
sourcePublishedAt: Timestamp.nullable(),
|
|
firstSeenAt: Timestamp,
|
|
lastSeenAt: Timestamp,
|
|
detailFetchedAt: Timestamp.nullable(),
|
|
/** 标题解析结果(标题/年份/季集/分辨率/来源/编码/发布组…) */
|
|
parsed: JsonObject,
|
|
parserVersion: z.string().nullable(),
|
|
mediaEntityId: Id.nullable(),
|
|
contentUnitId: Id.nullable(),
|
|
resolutionStatus: ResolutionStatus,
|
|
resolutionEvidence: JsonObject,
|
|
availability: ReleaseAvailability,
|
|
raw: JsonObject,
|
|
});
|
|
export type SourceRelease = z.infer<typeof SourceRelease>;
|
|
/** 由适配器/任务写入(按 siteId+siteReleaseId upsert) */
|
|
export const SourceReleaseCreate = SourceRelease.omit({
|
|
...SERVER_MANAGED,
|
|
firstSeenAt: true,
|
|
lastSeenAt: true,
|
|
}).partial({
|
|
subtitle: true,
|
|
categoryRaw: true,
|
|
tagsRaw: true,
|
|
sizeBytes: true,
|
|
infohashV1: true,
|
|
infohashV2: true,
|
|
fileList: true,
|
|
promotion: true,
|
|
promotionExpiresAt: true,
|
|
seeders: true,
|
|
leechers: true,
|
|
sourcePublishedAt: true,
|
|
detailFetchedAt: true,
|
|
parsed: true,
|
|
parserVersion: true,
|
|
mediaEntityId: true,
|
|
contentUnitId: true,
|
|
resolutionStatus: true,
|
|
resolutionEvidence: true,
|
|
availability: true,
|
|
raw: true,
|
|
});
|
|
export type SourceReleaseCreate = z.infer<typeof SourceReleaseCreate>;
|
|
export const SourceReleaseUpdate = SourceReleaseCreate.omit({ siteId: true, siteReleaseId: true }).partial();
|
|
export type SourceReleaseUpdate = z.infer<typeof SourceReleaseUpdate>;
|
|
|
|
export const ObservationStatus = z.enum(["new", "linked", "ignored", "error"]);
|
|
export type ObservationStatus = z.infer<typeof ObservationStatus>;
|
|
|
|
export const Observation = EntityBase.extend({
|
|
feedId: Id,
|
|
guid: z.string().min(1),
|
|
contentDigest: z.string().min(1),
|
|
sourceReleaseId: Id.nullable(),
|
|
title: z.string(),
|
|
/** 已脱敏的链接;原始下载链接不对外 */
|
|
linkRedacted: z.string().nullable(),
|
|
raw: JsonObject,
|
|
sourcePublishedAt: Timestamp.nullable(),
|
|
fetchedAt: Timestamp,
|
|
firstSeenAt: Timestamp,
|
|
lastSeenAt: Timestamp,
|
|
status: ObservationStatus,
|
|
resolveAttempts: NonNegInt,
|
|
nextResolveAt: Timestamp.nullable(),
|
|
lastError: JsonObject.nullable(),
|
|
});
|
|
export type Observation = z.infer<typeof Observation>;
|
|
export const ObservationCreate = Observation.pick({
|
|
feedId: true,
|
|
guid: true,
|
|
contentDigest: true,
|
|
sourceReleaseId: true,
|
|
title: true,
|
|
linkRedacted: true,
|
|
raw: true,
|
|
sourcePublishedAt: true,
|
|
fetchedAt: true,
|
|
}).partial({ sourceReleaseId: true, linkRedacted: true, raw: true, sourcePublishedAt: true, fetchedAt: true });
|
|
export type ObservationCreate = z.infer<typeof ObservationCreate>;
|
|
export const ObservationUpdate = Observation.pick({
|
|
contentDigest: true,
|
|
sourceReleaseId: true,
|
|
title: true,
|
|
raw: true,
|
|
status: true,
|
|
resolveAttempts: true,
|
|
nextResolveAt: true,
|
|
lastError: true,
|
|
}).partial();
|
|
export type ObservationUpdate = z.infer<typeof ObservationUpdate>;
|