283 lines
14 KiB
TypeScript
283 lines
14 KiB
TypeScript
export type QzonePublicObject = Record<string, unknown>;
|
|
export type QzonePublicContent = string | QzonePublicObject[];
|
|
export type QzonePublicOperation =
|
|
| 'capabilities' | 'feeds' | 'detail' | 'comments' | 'replies'
|
|
| 'upvote' | 'downvote' | 'like' | 'unlike' | 'follow' | 'unfollow'
|
|
| 'commentLike' | 'commentUnlike' | 'addComment' | 'addReply'
|
|
| 'deleteComment' | 'deleteReply' | 'forward';
|
|
|
|
export interface QzonePublicFeedsPage extends QzonePublicObject {
|
|
feeds: QzonePublicObject[];
|
|
has_more: boolean;
|
|
next_cursor: string | null;
|
|
}
|
|
|
|
export interface QzonePublicRequestOptions extends QzonePublicObject {
|
|
feed?: QzonePublicObject;
|
|
comment?: QzonePublicObject;
|
|
reply?: QzonePublicObject;
|
|
content?: QzonePublicContent;
|
|
cursor?: string;
|
|
pageSize?: number;
|
|
reason?: string;
|
|
selfUin?: string;
|
|
user?: QzonePublicObject;
|
|
refreshId?: string;
|
|
lastUnionId?: QzonePublicObject;
|
|
}
|
|
|
|
export interface QzonePublicRoute {
|
|
service: string;
|
|
method: string;
|
|
oidb: string;
|
|
}
|
|
|
|
const READER = 'trpc.qzone.feeds_reader.FeedsReader';
|
|
const WRITER = 'trpc.qzone.feeds_writer.FeedsWriter';
|
|
const INTERACTION = 'trpc.qzone.interaction_writer.InteractionWriter';
|
|
const RELATION = 'trpc.public_qzone.relation.RelationService';
|
|
const UPVOTE = 'trpc.public_qzone.interaction.UFOComment';
|
|
const MAX_OBJECT_BYTES = 8 * 1024 * 1024;
|
|
const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
|
|
const MAX_IDENTITY_LENGTH = 8192;
|
|
|
|
function route (service: string, method: string, oidb: string): QzonePublicRoute {
|
|
return Object.freeze({ service, method, oidb });
|
|
}
|
|
|
|
export const QZONE_PUBLIC_ROUTES: Record<QzonePublicOperation, QzonePublicRoute> = Object.freeze({
|
|
capabilities: route('trpc.public_qzone.entrance_ctrl.EntranceCtrl', 'BatchEntranceWhitelist', '0x9741_0'),
|
|
feeds: route(READER, 'GetPublicRecomFeeds', '0x9a38_0'),
|
|
detail: route(READER, 'GetFeedDetail', '0x97b1_1'),
|
|
comments: route(READER, 'GetComment', '0x9bfd_1'),
|
|
replies: route(READER, 'GetReplies', '0x9bfe_1'),
|
|
upvote: route(UPVOTE, 'Upvote', '0x9d18_1'),
|
|
downvote: route(UPVOTE, 'Downvote', '0x9d19_1'),
|
|
like: route(INTERACTION, 'DoLike', '0x9699_1'),
|
|
unlike: route(INTERACTION, 'UnLike', '0x969c_1'),
|
|
follow: route(RELATION, 'Follow', '0x9d1a_1'),
|
|
unfollow: route(RELATION, 'Unfollow', '0x9d1b_1'),
|
|
commentLike: route(INTERACTION, 'DoLike', '0x9699_1'),
|
|
commentUnlike: route(INTERACTION, 'UnLike', '0x969c_1'),
|
|
addComment: route(INTERACTION, 'AddComment', '0x9676_1'),
|
|
addReply: route(INTERACTION, 'AddReply', '0x9677_1'),
|
|
deleteComment: route(INTERACTION, 'DeleteComment', '0x9989_0'),
|
|
deleteReply: route(INTERACTION, 'DeleteReply', '0x998a_0'),
|
|
forward: route(WRITER, 'ForwardFeed', '0x969a_1'),
|
|
});
|
|
|
|
function object (value: unknown): value is QzonePublicObject {
|
|
if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
|
|
const prototype = Object.getPrototypeOf(value);
|
|
return prototype === Object.prototype || prototype === null;
|
|
}
|
|
|
|
function assertOperation (operation: QzonePublicOperation): void {
|
|
if (!Object.prototype.hasOwnProperty.call(QZONE_PUBLIC_ROUTES, operation)) throw new Error('QQ空间公开接口操作无效');
|
|
}
|
|
|
|
/** Clone JSON without calling toJSON or assigning prototype setters. */
|
|
function snapshot<T> (value: T, name: string, maxBytes = MAX_OBJECT_BYTES): T {
|
|
const seen = new Set<object>();
|
|
let nodes = 0;
|
|
const maxNodes = 200000;
|
|
const maxDepth = 64;
|
|
function copy (input: unknown, depth: number): unknown {
|
|
if (++nodes > maxNodes || depth > maxDepth) throw new Error(`${name}结构超出限制`);
|
|
if (input === null || typeof input === 'boolean') return input;
|
|
if (typeof input === 'string') {
|
|
if (Buffer.byteLength(input, 'utf8') > maxBytes) throw new Error(`${name}超过大小限制`);
|
|
return input;
|
|
}
|
|
if (typeof input === 'number' && Number.isFinite(input)) return input;
|
|
if (!Array.isArray(input) && !object(input)) throw new Error(`${name}必须为JSON数据`);
|
|
if (seen.has(input)) throw new Error(`${name}不能包含循环引用`);
|
|
seen.add(input);
|
|
let output: unknown;
|
|
if (Array.isArray(input)) {
|
|
const items: unknown[] = [];
|
|
for (let index = 0; index < input.length; index++) items.push(copy(input[index], depth + 1));
|
|
output = items;
|
|
} else {
|
|
const result: QzonePublicObject = {};
|
|
for (const key of Object.keys(input)) {
|
|
const item = input[key];
|
|
if (item === undefined) continue;
|
|
Object.defineProperty(result, key, { value: copy(item, depth + 1), enumerable: true, configurable: true, writable: true });
|
|
}
|
|
output = result;
|
|
}
|
|
seen.delete(input);
|
|
return output;
|
|
}
|
|
const result = copy(value, 0) as T;
|
|
if (Buffer.byteLength(JSON.stringify(result), 'utf8') > maxBytes) throw new Error(`${name}超过大小限制`);
|
|
return result;
|
|
}
|
|
|
|
function jsonObject (value: unknown, name: string): QzonePublicObject {
|
|
if (!object(value)) throw new Error(`${name}必须为JSON对象`);
|
|
return snapshot(value, name);
|
|
}
|
|
|
|
function identity (value: unknown, name: string, allowEmpty = false): string {
|
|
if (typeof value !== 'string' || value.length > MAX_IDENTITY_LENGTH || (!allowEmpty && !value.trim())) {
|
|
throw new Error(`${name}无效`);
|
|
}
|
|
for (const character of value) {
|
|
const code = character.charCodeAt(0);
|
|
if (code < 32 || code === 127) throw new Error(`${name}无效`);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function uin (value: unknown, name: string): string {
|
|
if (typeof value !== 'string' || !/^[1-9]\d{0,19}$/.test(value)) throw new Error(`${name}无效`);
|
|
return value;
|
|
}
|
|
|
|
function pageToken (value: unknown, name: string, allowEmpty = false, maxLength = MAX_OBJECT_BYTES): string {
|
|
if (typeof value !== 'string' || value.length > maxLength || (!allowEmpty && value.length === 0)) throw new Error(`${name}无效`);
|
|
return value;
|
|
}
|
|
|
|
function unionId (value: unknown): QzonePublicObject {
|
|
const union = jsonObject(value, 'QQ空间完整动态标识');
|
|
let identified = false;
|
|
for (const key of ['uf_key', 'ugc_id', 'feed_id', 'serialized_data']) {
|
|
if (union[key] === undefined || union[key] === null) continue;
|
|
const field = identity(union[key], 'QQ空间动态身份字段', true);
|
|
if (field.trim()) identified = true;
|
|
}
|
|
if (!identified) throw new Error('QQ空间动态缺少完整有效身份');
|
|
if (union['ext_ids'] !== undefined && union['ext_ids'] !== null && (!Array.isArray(union['ext_ids']) || union['ext_ids'].some(item => !object(item)))) {
|
|
throw new Error('QQ空间动态扩展身份无效');
|
|
}
|
|
return union;
|
|
}
|
|
|
|
function readComment (value: unknown, name: string): QzonePublicObject {
|
|
const comment = jsonObject(value, name);
|
|
const id = comment['id'];
|
|
if (typeof id === 'string') identity(id, `${name}标识`);
|
|
else if (typeof id !== 'number' || !Number.isSafeInteger(id) || id < 0) throw new Error(`${name}标识无效`);
|
|
if (comment['user'] !== undefined && !object(comment['user'])) throw new Error(`${name}用户必须为JSON对象`);
|
|
return comment;
|
|
}
|
|
|
|
function user (value: unknown, name: string): QzonePublicObject {
|
|
const result = jsonObject(value, name);
|
|
const userUin = result['uin'];
|
|
const userUid = result['uid'];
|
|
const absentUin = userUin === undefined || userUin === null || userUin === '' || userUin === '0' || userUin === 0;
|
|
if (!absentUin) uin(userUin, `${name}QQ号`);
|
|
if (userUid !== undefined && userUid !== null && userUid !== '') identity(userUid, `${name}UID`);
|
|
if (absentUin && !userUid) throw new Error(`${name}缺少QQ号或UID`);
|
|
return result;
|
|
}
|
|
|
|
function content (value: unknown): QzonePublicObject[] {
|
|
if (typeof value === 'string') {
|
|
if (!value.length) throw new Error('QQ空间评论正文不能为空');
|
|
return snapshot([{ type: 0, content: value }], 'QQ空间评论正文');
|
|
}
|
|
if (!Array.isArray(value) || !value.length) throw new Error('QQ空间评论正文必须为非空文本或RichMsg数组');
|
|
const items = snapshot(value, 'QQ空间评论正文');
|
|
for (const item of items) {
|
|
if (!object(item)) throw new Error('QQ空间RichMsg条目必须为JSON对象');
|
|
}
|
|
return items as QzonePublicObject[];
|
|
}
|
|
|
|
export function buildQzonePublicRequest (operation: QzonePublicOperation, options: QzonePublicRequestOptions): QzonePublicObject {
|
|
assertOperation(operation);
|
|
if (!object(options)) throw new Error('QQ空间公开接口参数必须为对象');
|
|
if (operation === 'capabilities') return { uins: [uin(options.selfUin, '当前QQ号')], entrance_types: [1, 15] };
|
|
if (operation === 'feeds') {
|
|
const body: QzonePublicObject = { refresh_id: identity(options.refreshId, 'QQ空间刷新标识') };
|
|
if (options.cursor !== undefined) body['attach_info'] = pageToken(options.cursor, 'QQ空间分页标识', true, 65536);
|
|
if (options.lastUnionId !== undefined) body['last_client_feed_union_id'] = unionId(options.lastUnionId);
|
|
return body;
|
|
}
|
|
|
|
const feed = jsonObject(options.feed, 'QQ空间原始Feed');
|
|
const common = feed['cell_common'];
|
|
if (!object(common)) throw new Error('QQ空间原始Feed缺少cell_common');
|
|
const union = unionId(common['union_id']);
|
|
const body: QzonePublicObject = { union_id: union };
|
|
if (feed['cell_feed_transfer'] !== undefined) body['cell_feed_transfer'] = snapshot(feed['cell_feed_transfer'], 'QQ空间动态上下文');
|
|
|
|
if (operation === 'detail') return { ...body, feed_action_domain_type: 3, from_page: 1 };
|
|
if (operation === 'comments') return { ...body, attach_info: pageToken(options.cursor, 'QQ空间评论分页标识') };
|
|
if (operation === 'replies') {
|
|
const parent = readComment(options.comment, 'QQ空间父评论');
|
|
const size = options.pageSize === undefined ? 20 : options.pageSize;
|
|
if (typeof size !== 'number' || !Number.isFinite(size) || size < 1) throw new Error('QQ空间回复page_size必须为不小于1的有限数值');
|
|
const pointer = options.cursor || parent['reply_attach_info'] || '';
|
|
return { ...body, cur_comment: parent, comment_attach_info: '', reply_attach_info: pageToken(pointer, 'QQ空间回复分页标识', true), page_size: Math.trunc(size) };
|
|
}
|
|
if (operation === 'upvote' || operation === 'downvote') return body;
|
|
if (operation === 'like' || operation === 'unlike') {
|
|
return { ...body, like_key: identity(common['cur_like_key'], 'QQ空间动态点赞标识'), like_type: 1 };
|
|
}
|
|
if (operation === 'follow' || operation === 'unfollow') {
|
|
const userInfo = feed['cell_user_info'];
|
|
const author = user(object(userInfo) ? userInfo['user'] : undefined, 'QQ空间动态作者');
|
|
const authorUin = typeof author['uin'] === 'string' && /^[1-9]\d{0,19}$/.test(author['uin']) ? author['uin'] : '';
|
|
const authorUid = typeof author['uid'] === 'string' ? author['uid'].trim() : '';
|
|
const useUid = (common['domain_type'] === 3 && !!authorUid) || !authorUin;
|
|
const request: QzonePublicObject = { follow_from_type: 1, ...(useUid ? { target_uid: authorUid } : { target_uin: authorUin }) };
|
|
if ((useUid && !authorUid) || (!useUid && !authorUin)) throw new Error('QQ空间动态缺少可蹲的作者身份');
|
|
if (typeof union['uf_key'] === 'string' && union['uf_key']) request['follow_feed_id'] = union['uf_key'];
|
|
if (feed['cell_feed_transfer']) request['cell_feed_transfer'] = body['cell_feed_transfer'];
|
|
return request;
|
|
}
|
|
if (operation === 'commentLike' || operation === 'commentUnlike') {
|
|
const parent = readComment(options.comment, 'QQ空间父评论');
|
|
const target = options.reply === undefined ? parent : readComment(options.reply, 'QQ空间回复');
|
|
const like = target['like'];
|
|
return { ...body, like_key: identity(object(like) ? like['id'] : undefined, 'QQ空间评论点赞标识'), like_type: options.reply === undefined ? 2 : 3 };
|
|
}
|
|
if (operation === 'addComment') return { ...body, comment: { user: user(options.user, '当前用户'), content: content(options.content) } };
|
|
if (operation === 'addReply') {
|
|
const parent = readComment(options.comment, 'QQ空间父评论');
|
|
const target = options.reply === undefined ? parent : readComment(options.reply, 'QQ空间回复');
|
|
return { ...body, comment: parent, reply: { content: content(options.content), target_user: user(target['user'], 'QQ空间回复目标'), user: user(options.user, '当前用户') } };
|
|
}
|
|
if (operation === 'deleteComment') return { ...body, comment: readComment(options.comment, 'QQ空间父评论') };
|
|
if (operation === 'deleteReply') return { ...body, comment: readComment(options.comment, 'QQ空间父评论'), reply: readComment(options.reply, 'QQ空间回复') };
|
|
if (operation === 'forward') {
|
|
const reason = options.reason ?? '';
|
|
if (typeof reason !== 'string') throw new Error('QQ空间转发理由必须为文本');
|
|
return { ...body, reason: snapshot(reason, 'QQ空间转发理由') };
|
|
}
|
|
throw new Error('QQ空间公开接口操作无效');
|
|
}
|
|
|
|
/** Return the business data, preserving unknown fields while checking the observed acknowledgements. */
|
|
export function parseQzonePublicResponse (value: unknown, operation: QzonePublicOperation): QzonePublicObject {
|
|
assertOperation(operation);
|
|
if (object(value) && typeof value['retcode'] === 'number' && Number.isSafeInteger(value['retcode']) && value['retcode'] !== 0) {
|
|
throw new Error(`QQ空间公开接口拒绝请求 (retcode=${value['retcode']})`);
|
|
}
|
|
if (!object(value) || value['retcode'] !== 0 || !object(value['data'])) throw new Error('QQ空间公开接口未返回明确成功响应');
|
|
const data = snapshot(value['data'], 'QQ空间公开接口响应', MAX_RESPONSE_BYTES);
|
|
if (operation === 'follow' || operation === 'unfollow') {
|
|
const code = data['ret_code'];
|
|
if (code !== undefined && code !== null && code !== 0 && code !== '0') throw new Error('QQ空间蹲操作未确认成功');
|
|
}
|
|
const resultFields: Partial<Record<QzonePublicOperation, string>> = {
|
|
upvote: 'upvote',
|
|
downvote: 'upvote',
|
|
like: 'like',
|
|
unlike: 'like',
|
|
commentLike: 'like',
|
|
commentUnlike: 'like',
|
|
addComment: 'comment',
|
|
addReply: 'reply',
|
|
};
|
|
const field = resultFields[operation];
|
|
if (field && !data[field]) throw new Error('QQ空间公开互动未返回业务成功结果');
|
|
return data;
|
|
}
|