227 lines
8.8 KiB
TypeScript
227 lines
8.8 KiB
TypeScript
import { WORKS_SQUARE_CONFIG } from '../api/works-config';
|
|
import { proxyAwareFetch } from '../utils/proxy-fetch';
|
|
import { getValidWorksSquareAccessToken } from './works-square-session';
|
|
import {
|
|
LEARNING_MATERIAL_MAX_FILE_BYTES,
|
|
LEARNING_MATERIAL_MAX_FILES,
|
|
LEARNING_MATERIAL_MAX_TOTAL_BYTES,
|
|
LEARNING_GENERATION_CONTRACT_VERSION,
|
|
type LearningGeneration,
|
|
type LearningGenerationOptions,
|
|
type LearningGenerationUploadRequest,
|
|
} from '../../shared/learning';
|
|
|
|
type Dependencies = {
|
|
fetchImpl?: typeof fetch;
|
|
getAccessToken?: typeof getValidWorksSquareAccessToken;
|
|
apiBaseUrl?: string;
|
|
};
|
|
|
|
function record(value: unknown): Record<string, unknown> {
|
|
return value && typeof value === 'object' && !Array.isArray(value)
|
|
? value as Record<string, unknown>
|
|
: {};
|
|
}
|
|
|
|
function nullableString(value: unknown, maxLength: number): string | null {
|
|
if (value === null) return null;
|
|
if (typeof value !== 'string' || value.length > maxLength) throw new Error('课程任务创建失败');
|
|
return value;
|
|
}
|
|
|
|
function nullableInteger(value: unknown, min: number, max: number): number | null {
|
|
if (value === null) return null;
|
|
if (!Number.isSafeInteger(value) || Number(value) < min || Number(value) > max) {
|
|
throw new Error('课程任务创建失败');
|
|
}
|
|
return Number(value);
|
|
}
|
|
|
|
function projectGeneration(value: unknown): LearningGeneration {
|
|
const generation = record(value);
|
|
const contractVersion = generation.contractVersion === undefined
|
|
? undefined
|
|
: Number.isSafeInteger(generation.contractVersion)
|
|
&& Number(generation.contractVersion) === LEARNING_GENERATION_CONTRACT_VERSION
|
|
? Number(generation.contractVersion)
|
|
: null;
|
|
const jobId = typeof generation.jobId === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(generation.jobId)
|
|
? generation.jobId
|
|
: null;
|
|
const status = typeof generation.status === 'string' && /^[a-z][a-z0-9_-]{0,63}$/.test(generation.status)
|
|
? generation.status
|
|
: null;
|
|
const mode = generation.mode === undefined
|
|
? undefined
|
|
: generation.mode === 'single' || generation.mode === 'large' ? generation.mode : null;
|
|
const progress = generation.progress === null ? null : generation.progress;
|
|
const courseId = generation.courseId === null
|
|
? null
|
|
: typeof generation.courseId === 'string' && /^[A-Za-z0-9_-]{1,64}$/.test(generation.courseId)
|
|
? generation.courseId
|
|
: undefined;
|
|
if (contractVersion === null || !jobId || !status || mode === null || typeof generation.done !== 'boolean'
|
|
|| courseId === undefined
|
|
|| (progress !== null && (typeof progress !== 'number' || !Number.isFinite(progress) || progress < 0 || progress > 100))) {
|
|
throw new Error('课程任务创建失败');
|
|
}
|
|
return {
|
|
...(contractVersion === undefined ? {} : { contractVersion }),
|
|
jobId,
|
|
status,
|
|
...(mode === undefined ? {} : { mode }),
|
|
step: nullableString(generation.step, 128),
|
|
progress,
|
|
message: nullableString(generation.message, 2_000),
|
|
scenesGenerated: nullableInteger(generation.scenesGenerated, 0, 100_000),
|
|
totalScenes: nullableInteger(generation.totalScenes, 0, 100_000),
|
|
courseId,
|
|
error: generation.error === null ? null : (nullableString(generation.error, 2_000), '课程生成失败'),
|
|
done: generation.done,
|
|
};
|
|
}
|
|
|
|
const INVALID_UPLOAD_ERROR = '课程任务创建失败';
|
|
const MATERIAL_ID_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
|
|
const MIME_TYPE_PATTERN = /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/;
|
|
const MAX_MATERIAL_TIMESTAMP = 8_640_000_000_000_000;
|
|
|
|
function invalidUpload(): never {
|
|
throw new Error(INVALID_UPLOAD_ERROR);
|
|
}
|
|
|
|
function hasControlCharacter(value: string): boolean {
|
|
return [...value].some((character) => {
|
|
const code = character.codePointAt(0) ?? 0;
|
|
return code <= 31 || code === 127;
|
|
});
|
|
}
|
|
|
|
function validateOptions(value: unknown): LearningGenerationOptions {
|
|
const options = record(value);
|
|
const rawRequirement = typeof options.requirement === 'string' ? options.requirement : '';
|
|
const requirement = rawRequirement.trim();
|
|
if (!requirement || rawRequirement.length > 4_000) invalidUpload();
|
|
const booleanKeys = [
|
|
'enableWebSearch',
|
|
'enableImageGeneration',
|
|
'enableVideoGeneration',
|
|
'enableTTS',
|
|
'interactiveMode',
|
|
'taskEngineMode',
|
|
] as const;
|
|
for (const key of booleanKeys) {
|
|
if (typeof options[key] !== 'boolean') invalidUpload();
|
|
}
|
|
return {
|
|
requirement,
|
|
enableWebSearch: options.enableWebSearch as boolean,
|
|
enableImageGeneration: options.enableImageGeneration as boolean,
|
|
enableVideoGeneration: options.enableVideoGeneration as boolean,
|
|
enableTTS: options.enableTTS as boolean,
|
|
interactiveMode: options.interactiveMode as boolean,
|
|
taskEngineMode: options.taskEngineMode as boolean,
|
|
};
|
|
}
|
|
|
|
function validateMaterials(value: unknown): Array<{
|
|
name: string;
|
|
mimeType: string;
|
|
order: number;
|
|
bytes: Uint8Array;
|
|
}> {
|
|
if (!Array.isArray(value) || value.length > LEARNING_MATERIAL_MAX_FILES) invalidUpload();
|
|
let totalBytes = 0;
|
|
const ids = new Set<string>();
|
|
const orders = new Set<number>();
|
|
const validated = value.map((candidate) => {
|
|
const material = record(candidate);
|
|
const id = material.id;
|
|
const name = material.name;
|
|
const mimeType = material.mimeType;
|
|
const size = material.size;
|
|
const lastModified = material.lastModified;
|
|
const order = material.order;
|
|
const bytes = material.bytes;
|
|
if (typeof id !== 'string' || !MATERIAL_ID_PATTERN.test(id) || ids.has(id)
|
|
|| typeof name !== 'string' || !name.trim() || name.length > 255
|
|
|| name.includes('/') || name.includes('\\') || hasControlCharacter(name)
|
|
|| typeof mimeType !== 'string' || mimeType.length > 128 || !MIME_TYPE_PATTERN.test(mimeType)
|
|
|| !Number.isSafeInteger(size) || Number(size) <= 0 || Number(size) > LEARNING_MATERIAL_MAX_FILE_BYTES
|
|
|| !Number.isSafeInteger(lastModified) || Number(lastModified) < 0 || Number(lastModified) > MAX_MATERIAL_TIMESTAMP
|
|
|| !Number.isSafeInteger(order) || Number(order) < 1 || Number(order) > value.length
|
|
|| orders.has(Number(order))
|
|
|| !(bytes instanceof Uint8Array)
|
|
|| bytes.byteLength !== Number(size)) invalidUpload();
|
|
ids.add(id);
|
|
orders.add(Number(order));
|
|
totalBytes += bytes.byteLength;
|
|
if (totalBytes > LEARNING_MATERIAL_MAX_TOTAL_BYTES) invalidUpload();
|
|
const projectedBytes = new Uint8Array(bytes.byteLength);
|
|
projectedBytes.set(bytes);
|
|
return { name, mimeType, order: Number(order), bytes: projectedBytes };
|
|
}).sort((left, right) => left.order - right.order);
|
|
return validated;
|
|
}
|
|
|
|
export function createLearningGenerationClient(dependencies: Dependencies = {}) {
|
|
const fetchImpl = dependencies.fetchImpl ?? proxyAwareFetch;
|
|
const getAccessToken = dependencies.getAccessToken ?? getValidWorksSquareAccessToken;
|
|
const apiBaseUrl = (dependencies.apiBaseUrl ?? WORKS_SQUARE_CONFIG.apiBaseUrl).replace(/\/+$/, '');
|
|
|
|
async function start(
|
|
input: LearningGenerationUploadRequest,
|
|
assertCurrentAccount: () => void = () => undefined,
|
|
): Promise<LearningGeneration> {
|
|
const upload = record(input);
|
|
const options = validateOptions(upload.options);
|
|
const materials = validateMaterials(upload.materials);
|
|
assertCurrentAccount();
|
|
const token = await getAccessToken({ fetchImpl }).catch(() => { throw new Error('课程任务创建失败'); });
|
|
assertCurrentAccount();
|
|
if (!token) throw new Error('请先登录');
|
|
|
|
const form = materials.length > 0 ? new FormData() : null;
|
|
if (form) {
|
|
form.set('options', JSON.stringify(options));
|
|
for (const { name, mimeType, bytes } of materials) {
|
|
form.append(
|
|
'materials',
|
|
new Blob([bytes.buffer], { type: mimeType }),
|
|
name,
|
|
);
|
|
}
|
|
}
|
|
const request = (accessToken: string) => {
|
|
assertCurrentAccount();
|
|
return fetchImpl(`${apiBaseUrl}/api/learning/generations`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
Authorization: `Bearer ${accessToken}`,
|
|
...(form ? {} : { 'Content-Type': 'application/json' }),
|
|
},
|
|
body: form ?? JSON.stringify(options),
|
|
redirect: 'manual',
|
|
});
|
|
};
|
|
let response = await request(token).catch(() => { throw new Error('课程任务创建失败'); });
|
|
assertCurrentAccount();
|
|
if (response.status === 401) {
|
|
await response.body?.cancel().catch(() => undefined);
|
|
assertCurrentAccount();
|
|
const refreshed = await getAccessToken({ fetchImpl, forceRefresh: true }).catch(() => null);
|
|
assertCurrentAccount();
|
|
if (refreshed) {
|
|
response = await request(refreshed).catch(() => { throw new Error('课程任务创建失败'); });
|
|
assertCurrentAccount();
|
|
}
|
|
}
|
|
const payload = await response.json().catch(() => null);
|
|
if (!response.ok || !payload) throw new Error('课程任务创建失败');
|
|
return projectGeneration(payload);
|
|
}
|
|
|
|
return { start };
|
|
}
|