457 lines
24 KiB
TypeScript
457 lines
24 KiB
TypeScript
import { createHash, randomUUID } from 'node:crypto';
|
||
import { lookup } from 'node:dns/promises';
|
||
import { request as httpsRequest } from 'node:https';
|
||
import { isIP, type LookupFunction } from 'node:net';
|
||
import { GetObjectCommand, PutObjectCommand, type S3Client } from '@aws-sdk/client-s3';
|
||
import type { MediaAiEditFailureStage, MediaAiEditSettings } from '@atlas/contracts';
|
||
import type { Database } from '@atlas/database';
|
||
import sharp from 'sharp';
|
||
import { buildMediaAiPrompt } from './media-ai-prompt.js';
|
||
import type { OutboxJob } from './outbox-dispatcher.js';
|
||
|
||
type StoredAsset = { id: string; storage_provider: string; bucket: string; object_key: string };
|
||
type EditTask = {
|
||
status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
|
||
source_asset_id: string;
|
||
reference_asset_ids: string[];
|
||
settings: MediaAiEditSettings;
|
||
provider_task_id: string | null;
|
||
created_at: Date | string;
|
||
};
|
||
const sizes: Record<MediaAiEditSettings['ratio'], [number, number]> = {
|
||
'3:4': [1152, 1536], '1:1': [1024, 1024], '4:5': [1280, 1600],
|
||
};
|
||
type AiEditFailureCode = 'AI_IMAGE_GENERATION_FAILED' | 'AI_IMAGE_CONTENT_REJECTED' | 'AI_IMAGE_PROVIDER_FAILED';
|
||
export type AiEditFailure = {
|
||
code: AiEditFailureCode;
|
||
source: 'pcore' | 'atlas';
|
||
stage: MediaAiEditFailureStage;
|
||
detail: string;
|
||
providerErrorRaw: string | null;
|
||
};
|
||
|
||
class AiEditStageError extends Error {
|
||
public constructor(public readonly stage: MediaAiEditFailureStage, public readonly cause: unknown) {
|
||
super(cause instanceof Error ? cause.message : '未知错误');
|
||
}
|
||
}
|
||
|
||
async function atStage<T>(stage: MediaAiEditFailureStage, action: () => Promise<T>): Promise<T> {
|
||
try { return await action(); }
|
||
catch (error) { throw error instanceof AiEditStageError ? error : new AiEditStageError(stage, error); }
|
||
}
|
||
|
||
/** 只保存可供排查的短摘要，避免把密钥或带签名的地址写入任务结果。 */
|
||
function safeFailureDetail(error: unknown, stage: MediaAiEditFailureStage): string {
|
||
const message = error instanceof Error ? error.message : '未知错误';
|
||
if (stage === 'task_setup' || stage === 'input_preparation' || stage === 'result_storage') {
|
||
if (['图片对象不存在', '源图片超过处理上限', '参考图片格式不受支持',
|
||
'参考图片素材不存在'].includes(message)) return message;
|
||
if (error instanceof PcoreResponseError) return message.slice(0, 500);
|
||
const code = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
|
||
&& /^[A-Z0-9_]{2,32}$/i.test(error.code) ? `（${error.code}）` : '';
|
||
return `${error instanceof Error ? error.name : 'Error'}${code}`;
|
||
}
|
||
return message.replace(/Bearer\s+\S+/gi, 'Bearer [已隐藏]')
|
||
.replace(/https?:\/\/[^\s)]+/gi, '[地址已隐藏]')
|
||
.replace(/(?:api[_-]?key|token|secret)\s*[:=]\s*\S+/gi, '[凭据已隐藏]')
|
||
.replace(/\bai-edits\/[^\s)]+/gi, '[对象键已隐藏]')
|
||
.slice(0, 500);
|
||
}
|
||
|
||
export function classifyAiEditFailure(error: unknown): AiEditFailure {
|
||
const stage = error instanceof AiEditStageError ? error.stage : 'task_setup';
|
||
const cause = error instanceof AiEditStageError ? error.cause : error;
|
||
const providerError = cause instanceof PcoreResponseError ? cause : null;
|
||
const transportFailure = (stage === 'provider_submission' || stage === 'provider_polling')
|
||
&& cause instanceof Error && ['TypeError', 'TimeoutError', 'AbortError'].includes(cause.name);
|
||
return {
|
||
code: 'AI_IMAGE_GENERATION_FAILED',
|
||
source: providerError || transportFailure ? 'pcore' : 'atlas',
|
||
stage,
|
||
detail: safeFailureDetail(cause, stage),
|
||
providerErrorRaw: providerError?.rawResponse ?? null,
|
||
};
|
||
}
|
||
|
||
export class PcoreResponseError extends Error {
|
||
public readonly rawResponse: string | null;
|
||
|
||
public constructor(message: string, rawResponse: string | null) {
|
||
super(message);
|
||
this.rawResponse = rawResponse ? rawResponse.slice(0, 32_768) : null;
|
||
}
|
||
}
|
||
|
||
class PcoreTerminalError extends PcoreResponseError {
|
||
public constructor(public readonly errorCode: AiEditFailureCode, rawResponse: string | null) {
|
||
super(errorCode === 'AI_IMAGE_CONTENT_REJECTED'
|
||
? 'Pcore 未能完成这次生图，可能是输入或生成结果被审核拦截'
|
||
: 'Pcore 图片任务失败', rawResponse);
|
||
}
|
||
}
|
||
|
||
function pcoreErrorText(value: unknown): string {
|
||
if (typeof value === 'string') return value;
|
||
if (!value || typeof value !== 'object') return '';
|
||
const error = value as { code?: unknown; message?: unknown };
|
||
return [error.code, error.message].filter((item) => typeof item === 'string').join(' ');
|
||
}
|
||
|
||
function pcoreFailureCode(value: unknown): AiEditFailureCode {
|
||
if (!value || typeof value !== 'object') return 'AI_IMAGE_PROVIDER_FAILED';
|
||
const error = value as { code?: unknown; type?: unknown };
|
||
const explicitCode = [error.code, error.type].filter((item) => typeof item === 'string').join(' ');
|
||
return /safety|content[_-]?policy|moderation|blocked/i.test(explicitCode)
|
||
? 'AI_IMAGE_CONTENT_REJECTED' : 'AI_IMAGE_PROVIDER_FAILED';
|
||
}
|
||
function publicIpv4(address: string): boolean {
|
||
if (isIP(address) !== 4) return false;
|
||
const [a, b, c] = address.split('.').map(Number);
|
||
return !(a === 0 || a === 10 || a === 127 || a >= 224
|
||
|| a === 100 && b >= 64 && b <= 127
|
||
|| a === 169 && b === 254
|
||
|| a === 172 && b >= 16 && b <= 31
|
||
|| a === 192 && (b === 168 || b === 0 && (c === 0 || c === 2))
|
||
|| a === 198 && (b === 18 || b === 19 || b === 51 && c === 100)
|
||
|| a === 203 && b === 0 && c === 113);
|
||
}
|
||
|
||
async function readObject(storage: S3Client, asset: StoredAsset): Promise<Buffer> {
|
||
const response = await storage.send(new GetObjectCommand({ Bucket: asset.bucket, Key: asset.object_key }));
|
||
if (!response.Body) throw new Error('图片对象不存在');
|
||
const chunks: Buffer[] = [];
|
||
let bytes = 0;
|
||
for await (const chunk of response.Body as AsyncIterable<Uint8Array>) {
|
||
bytes += chunk.byteLength;
|
||
if (bytes > 20 * 1024 * 1024) throw new Error('源图片超过处理上限');
|
||
chunks.push(Buffer.from(chunk));
|
||
}
|
||
return Buffer.concat(chunks, bytes);
|
||
}
|
||
|
||
/** 普通编辑向供应商传原始图片字节，避免转码改变参考图内容。 */
|
||
async function referenceImageDataUri(bytes: Buffer): Promise<string> {
|
||
const image = sharp(bytes, { limitInputPixels: 100_000_000, failOn: 'error' });
|
||
const meta = await image.metadata();
|
||
if (!['jpeg', 'png', 'webp'].includes(meta.format ?? '') || !meta.width || !meta.height)
|
||
throw new Error('参考图片格式不受支持');
|
||
const mime = meta.format === 'jpeg' ? 'image/jpeg' : `image/${meta.format}`;
|
||
return `data:${mime};base64,${bytes.toString('base64')}`;
|
||
}
|
||
|
||
async function outpaintInputs(bytes: Buffer): Promise<{ image: Buffer; mask: Buffer; original: Buffer; left: number; top: number }> {
|
||
const [width, height] = sizes['3:4'];
|
||
const original = await sharp(bytes, { limitInputPixels: 100_000_000, failOn: 'error' })
|
||
.rotate().resize(width, height, { fit: 'inside', withoutEnlargement: false })
|
||
.ensureAlpha().png().toBuffer();
|
||
const meta = await sharp(original).metadata();
|
||
const left = Math.floor((width - meta.width!) / 2);
|
||
const top = Math.floor((height - meta.height!) / 2);
|
||
const canvas = await sharp({ create: { width, height, channels: 4, background: '#00000000' } })
|
||
.composite([{ input: original, left, top }]).png().toBuffer();
|
||
const opaque = await sharp({ create: { width: meta.width!, height: meta.height!, channels: 4, background: '#ffffffff' } })
|
||
.png().toBuffer();
|
||
const mask = await sharp({ create: { width, height, channels: 4, background: '#00000000' } })
|
||
.composite([{ input: opaque, left, top }]).png().toBuffer();
|
||
return {
|
||
image: canvas,
|
||
mask,
|
||
original, left, top,
|
||
};
|
||
}
|
||
|
||
function providerConfig(): { base: string; key: string } {
|
||
const key = process.env.PCORE_API_KEY;
|
||
const rawBase = process.env.PCORE_BASE_URL?.trim();
|
||
if (!key || !rawBase) throw new Error('PCORE_API_KEY 和 PCORE_BASE_URL 必须配置');
|
||
const url = new URL(rawBase);
|
||
const path = url.pathname.replace(/\/+$/, '');
|
||
if (url.protocol !== 'https:' || url.username || url.password || url.port
|
||
|| !['', '/v1'].includes(path) || url.search || url.hash)
|
||
throw new Error('PCORE_BASE_URL 必须是 HTTPS 根地址或 /v1 地址');
|
||
return { base: `${url.origin}/v1`, key };
|
||
}
|
||
|
||
async function providerRequest(url: string, key: string, body?: Record<string, unknown>): Promise<Record<string, unknown>> {
|
||
const response = await fetch(url, {
|
||
method: body ? 'POST' : 'GET',
|
||
headers: { Authorization: `Bearer ${key}`, ...(body ? { 'Content-Type': 'application/json' } : {}) },
|
||
body: body ? JSON.stringify(body) : undefined,
|
||
signal: AbortSignal.timeout(body ? 90_000 : 35_000),
|
||
redirect: 'error',
|
||
});
|
||
if (!response.ok) throw new PcoreResponseError(
|
||
`Pcore 图片任务请求失败（HTTP ${response.status}）`, await response.text());
|
||
let result: Record<string, unknown>;
|
||
try {
|
||
result = await response.json() as Record<string, unknown>;
|
||
if (!result || typeof result !== 'object' || Array.isArray(result)) throw new Error('invalid response');
|
||
} catch {
|
||
throw new PcoreResponseError('Pcore 返回的图片任务响应不是有效 JSON 对象', null);
|
||
}
|
||
if (result.error && (body || !['failed', 'error', 'cancelled'].includes(String(result.status ?? ''))))
|
||
throw new PcoreResponseError(`Pcore 图片任务请求被拒绝${pcoreErrorText(result.error)
|
||
? `（${pcoreErrorText(result.error).slice(0, 200)}）` : ''}`,
|
||
JSON.stringify(result.error));
|
||
return result;
|
||
}
|
||
|
||
async function submitProvider(storage: S3Client, assets: StoredAsset[], settings: MediaAiEditSettings): Promise<string> {
|
||
const provider = await atStage('provider_submission', async () => providerConfig());
|
||
const size = sizes[settings.mode === 'outpaint' ? '3:4' : settings.ratio];
|
||
const main = await atStage('input_preparation', () => readObject(storage, assets[0]));
|
||
const outpaint = settings.mode === 'outpaint'
|
||
? await atStage('input_preparation', () => outpaintInputs(main)) : null;
|
||
const images = await atStage('input_preparation', async () => outpaint
|
||
? [`data:image/png;base64,${outpaint.image.toString('base64')}`]
|
||
: await Promise.all(assets.map(async (asset, index) =>
|
||
referenceImageDataUri(index === 0 ? main : await readObject(storage, asset)))));
|
||
const body: Record<string, unknown> = {
|
||
model: 'gpt-image-2', prompt: buildMediaAiPrompt(settings), n: 1,
|
||
size: `${size[0]}x${size[1]}`, async: true,
|
||
images: images.map((image_url) => ({ image_url })),
|
||
};
|
||
if (outpaint) body.mask = { image_url: `data:image/png;base64,${outpaint.mask.toString('base64')}` };
|
||
const result = await atStage('provider_submission', () =>
|
||
providerRequest(`${provider.base}/images/edits`, provider.key, body));
|
||
const id = result.task_id ?? result.id;
|
||
if (typeof id !== 'string' || !id || id.length > 256)
|
||
throw new AiEditStageError('provider_submission', new PcoreResponseError('Pcore 未返回有效的任务 ID', null));
|
||
return id;
|
||
}
|
||
|
||
export async function downloadProviderImage(urlValue: string): Promise<Buffer> {
|
||
const url = new URL(urlValue);
|
||
if (url.protocol !== 'https:' || url.username || url.password || url.port || isIP(url.hostname))
|
||
throw new Error('Pcore 结果地址不安全');
|
||
const addresses = await lookup(url.hostname, { all: true, family: 4 });
|
||
if (!addresses.length || addresses.some((item) => !publicIpv4(item.address)))
|
||
throw new Error('Pcore 结果地址不安全');
|
||
/** 固定到校验过的公网 IPv4，同时保留域名用于 TLS 证书校验。 */
|
||
const response = await new Promise<import('node:http').IncomingMessage>((resolve, reject) => {
|
||
const request = httpsRequest(url, {
|
||
lookup: pinnedLookup(addresses[0].address),
|
||
timeout: 60_000,
|
||
}, resolve);
|
||
request.on('error', reject);
|
||
request.on('timeout', () => request.destroy(new PcoreResponseError('Pcore 结果下载超时', null)));
|
||
request.end();
|
||
});
|
||
if (response.statusCode !== 200 || Number(response.headers['content-length'] ?? 0) > 25 * 1024 * 1024) {
|
||
response.resume();
|
||
throw new PcoreResponseError(`Pcore 结果下载失败（HTTP ${response.statusCode}）`, null);
|
||
}
|
||
const chunks: Buffer[] = [];
|
||
let size = 0;
|
||
for await (const chunk of response) {
|
||
size += chunk.length;
|
||
if (size > 25 * 1024 * 1024) {
|
||
response.destroy();
|
||
throw new Error('Pcore 结果超过处理上限');
|
||
}
|
||
chunks.push(Buffer.from(chunk));
|
||
}
|
||
return Buffer.concat(chunks, size);
|
||
}
|
||
|
||
export function pinnedLookup(address: string): LookupFunction {
|
||
return (_hostname, options, callback) => {
|
||
const pinned = { address, family: 4 };
|
||
if (options.all) callback(null, [pinned]);
|
||
else callback(null, pinned.address, pinned.family);
|
||
};
|
||
}
|
||
|
||
export function providerImageResult(result: Record<string, unknown>): Buffer | string {
|
||
const first = Array.isArray(result.data) ? result.data[0] as Record<string, unknown> | undefined : undefined;
|
||
for (const encoded of [first?.b64_json, first?.b64_image]) {
|
||
if (typeof encoded !== 'string' || !encoded.trim()) continue;
|
||
if (encoded.length > 35 * 1024 * 1024) throw new Error('Pcore 结果超过处理上限');
|
||
const bytes = Buffer.from(encoded.replace(/^data:[^,]*,/, ''), 'base64');
|
||
if (bytes.length) return bytes;
|
||
}
|
||
if (typeof first?.url === 'string' && first.url) return first.url;
|
||
throw new Error('Pcore 任务完成但没有图片');
|
||
}
|
||
|
||
async function pollProvider(taskId: string): Promise<Buffer | null> {
|
||
const provider = await atStage('provider_polling', async () => providerConfig());
|
||
const result = await atStage('provider_polling', () =>
|
||
providerRequest(`${provider.base}/images/edits/${encodeURIComponent(taskId)}`, provider.key));
|
||
const status = String(result.status ?? '');
|
||
if (['failed', 'error', 'cancelled'].includes(status))
|
||
throw new PcoreTerminalError(pcoreFailureCode(result.error),
|
||
JSON.stringify(result.error ?? result));
|
||
if (!['completed', 'succeeded'].includes(status)) return null;
|
||
const image = await atStage('result_download', async () => {
|
||
try { return providerImageResult(result); }
|
||
catch (error) {
|
||
throw new PcoreResponseError(error instanceof Error ? error.message : 'Pcore 图片结果无效', null);
|
||
}
|
||
});
|
||
return typeof image === 'string'
|
||
? atStage('result_download', () => downloadProviderImage(image)) : image;
|
||
}
|
||
|
||
async function schedulePoll(database: Database, workspaceId: string, id: string) {
|
||
await database.workspaceTransaction(workspaceId, async (tx) => {
|
||
const current = await tx.query<{ status: string }>(
|
||
'SELECT status FROM atlas.media_ai_edits WHERE id = $1 FOR UPDATE', [id],
|
||
);
|
||
if (current.rows[0]?.status !== 'running') return;
|
||
await tx.query(
|
||
`INSERT INTO atlas.outbox_events
|
||
(workspace_id, aggregate_type, aggregate_id, event_type, event_payload, deduplication_key, next_attempt_at)
|
||
VALUES (current_setting('app.workspace_id')::uuid, 'media_ai_edit', $1,
|
||
'media.ai_edit.requested', jsonb_build_object('edit_id', $1::uuid), $2, now() + interval '3 seconds')`,
|
||
[id, `${id}:${randomUUID()}`],
|
||
);
|
||
});
|
||
}
|
||
|
||
export async function normalizeAiEditOutput(bytes: Buffer, settings: MediaAiEditSettings, source?: Buffer): Promise<Buffer> {
|
||
const target = sizes[settings.mode === 'outpaint' ? '3:4' : settings.ratio];
|
||
const image = sharp(bytes, { limitInputPixels: 100_000_000, failOn: 'error' });
|
||
const meta = await image.metadata();
|
||
if (!['png', 'jpeg', 'webp'].includes(meta.format ?? '') || !meta.width || !meta.height)
|
||
throw new Error('Pcore 结果图片无效');
|
||
if (settings.mode === 'outpaint' && source) {
|
||
const restored = await outpaintInputs(source);
|
||
return image.rotate().resize(target[0], target[1], { fit: 'cover' })
|
||
.composite([{ input: restored.original, left: restored.left, top: restored.top }])
|
||
.flatten({ background: '#ffffff' }).jpeg({ quality: 92 }).toBuffer();
|
||
}
|
||
return image.rotate().resize(target[0], target[1], { fit: 'contain', background: '#ffffff' })
|
||
.flatten({ background: '#ffffff' }).jpeg({ quality: 92 }).toBuffer();
|
||
}
|
||
|
||
/** 每个 Outbox 事件只推进一次供应商状态，等待由下一条延迟事件承担。 */
|
||
export async function runMediaAiEdit(database: Database, storage: S3Client, job: OutboxJob) {
|
||
const id = String(job.payload.edit_id ?? '');
|
||
const task = await atStage('task_setup', () => database.workspaceTransaction(job.workspaceId, async (tx) => {
|
||
const result = await tx.query<EditTask>(
|
||
'SELECT status, source_asset_id, reference_asset_ids, settings, provider_task_id, created_at FROM atlas.media_ai_edits WHERE id = $1 FOR UPDATE', [id],
|
||
);
|
||
const current = result.rows[0];
|
||
if (!current || !['queued', 'running'].includes(current.status)) return null;
|
||
if (Date.now() - new Date(current.created_at).getTime() > 20 * 60_000)
|
||
throw new AiEditStageError('provider_polling', new PcoreResponseError('等待 Pcore 图片任务超时', null));
|
||
await tx.query(
|
||
`UPDATE atlas.media_ai_edits SET status = 'running', started_at = coalesce(started_at, now()) WHERE id = $1`, [id],
|
||
);
|
||
await tx.query(
|
||
`UPDATE atlas.operations SET status = 'running', started_at = coalesce(started_at, now()),
|
||
attempt_count = attempt_count + 1 WHERE id = $1 AND status IN ('queued', 'running')`, [id],
|
||
);
|
||
return current;
|
||
}));
|
||
if (!task) return;
|
||
const assetIds = [task.source_asset_id, ...task.reference_asset_ids];
|
||
const assets = await atStage('input_preparation', () => database.workspaceTransaction(job.workspaceId, async (tx) => {
|
||
const result = await tx.query<StoredAsset>(
|
||
`SELECT id, storage_provider, bucket, object_key FROM atlas.media_assets WHERE id = ANY($1::uuid[])`, [assetIds],
|
||
);
|
||
const byId = new Map(result.rows.map((item) => [item.id, item]));
|
||
return assetIds.map((assetId) => {
|
||
const asset = byId.get(assetId);
|
||
if (!asset) throw new Error('参考图片素材不存在');
|
||
return asset;
|
||
});
|
||
}));
|
||
if (!task.provider_task_id) {
|
||
const providerTaskId = await submitProvider(storage, assets, task.settings);
|
||
await atStage('task_setup', () => database.workspaceTransaction(job.workspaceId, async (tx) => {
|
||
await tx.query(
|
||
`UPDATE atlas.media_ai_edits SET provider_task_id = $2 WHERE id = $1 AND status = 'running' AND provider_task_id IS NULL`,
|
||
[id, providerTaskId],
|
||
);
|
||
}));
|
||
await atStage('task_setup', () => schedulePoll(database, job.workspaceId, id));
|
||
return;
|
||
}
|
||
let result: Buffer | null;
|
||
try {
|
||
result = await pollProvider(task.provider_task_id);
|
||
} catch (error) {
|
||
// 供应商任务已是终态，重试同一个任务 ID 不会改变结果。
|
||
if (!(error instanceof PcoreTerminalError)) throw error;
|
||
await markMediaAiEditFailed(database, job, {
|
||
code: error.errorCode, source: 'pcore', stage: 'provider_polling',
|
||
detail: safeFailureDetail(error, 'provider_polling'), providerErrorRaw: error.rawResponse,
|
||
});
|
||
return;
|
||
}
|
||
if (!result) {
|
||
await atStage('task_setup', () => schedulePoll(database, job.workspaceId, id));
|
||
return;
|
||
}
|
||
const source = task.settings.mode === 'outpaint'
|
||
? await atStage('result_processing', () => readObject(storage, assets[0])) : undefined;
|
||
const output = await atStage('result_processing', () => normalizeAiEditOutput(result, task.settings, source));
|
||
if (output.byteLength > 20 * 1024 * 1024)
|
||
throw new AiEditStageError('result_processing', new Error('AI 编辑结果超过素材上限'));
|
||
const checksum = createHash('sha256').update(output).digest('hex');
|
||
const objectKey = `ai-edits/${job.workspaceId}/${checksum}.jpg`;
|
||
const existing = await atStage('result_storage', () => database.workspaceTransaction(job.workspaceId, async (tx) => {
|
||
const row = await tx.query<{ id: string }>('SELECT id FROM atlas.media_assets WHERE checksum_sha256 = $1', [checksum]);
|
||
return row.rows[0]?.id ?? null;
|
||
}));
|
||
if (!existing) await atStage('result_storage', () => storage.send(new PutObjectCommand({
|
||
Bucket: assets[0].bucket, Key: objectKey, Body: output, ContentType: 'image/jpeg',
|
||
})));
|
||
const [width, height] = sizes[task.settings.mode === 'outpaint' ? '3:4' : task.settings.ratio];
|
||
await atStage('result_storage', () => database.workspaceTransaction(job.workspaceId, async (tx) => {
|
||
const current = await tx.query<{ status: string }>(
|
||
'SELECT status FROM atlas.media_ai_edits WHERE id = $1 FOR UPDATE', [id],
|
||
);
|
||
if (current.rows[0]?.status !== 'running') return;
|
||
const asset = await tx.query<{ id: string }>(
|
||
`INSERT INTO atlas.media_assets
|
||
(workspace_id, storage_provider, bucket, object_key, content_type, byte_size, checksum_sha256, width_px, height_px)
|
||
VALUES (current_setting('app.workspace_id')::uuid, $1, $2, $3, 'image/jpeg', $4, $5, $6, $7)
|
||
ON CONFLICT (workspace_id, checksum_sha256)
|
||
DO UPDATE SET checksum_sha256 = EXCLUDED.checksum_sha256 RETURNING id`,
|
||
[assets[0].storage_provider, assets[0].bucket, objectKey, output.byteLength, checksum, width, height],
|
||
);
|
||
const assetId = asset.rows[0].id;
|
||
await tx.query(
|
||
`UPDATE atlas.media_ai_edits SET status = 'succeeded', output_asset_id = $2, error_code = NULL,
|
||
completed_at = now() WHERE id = $1`, [id, assetId],
|
||
);
|
||
await tx.query(
|
||
`UPDATE atlas.operations SET status = 'succeeded', completed_at = now(),
|
||
result = jsonb_build_object('output_asset_id', $2::uuid), error_code = NULL, error_message = NULL
|
||
WHERE id = $1 AND status IN ('queued', 'running')`, [id, assetId],
|
||
);
|
||
}));
|
||
}
|
||
|
||
export async function markMediaAiEditFailed(
|
||
database: Database, job: OutboxJob, failure: AiEditFailure,
|
||
) {
|
||
const id = String(job.payload.edit_id ?? '');
|
||
const { code, source, stage, detail, providerErrorRaw } = failure;
|
||
const message = code === 'AI_IMAGE_CONTENT_REJECTED'
|
||
? 'Pcore 未能完成这次生图，可能是输入或生成结果被审核拦截'
|
||
: code === 'AI_IMAGE_PROVIDER_FAILED'
|
||
? 'Pcore 图片任务失败，请稍后重试'
|
||
: '单张 AI 编辑失败，请重试';
|
||
await database.workspaceTransaction(job.workspaceId, async (tx) => {
|
||
await tx.query(
|
||
`UPDATE atlas.media_ai_edits SET status = 'failed', error_code = $2,
|
||
completed_at = now() WHERE id = $1 AND status IN ('queued', 'running')`, [id, code],
|
||
);
|
||
await tx.query(
|
||
`UPDATE atlas.operations SET status = 'failed', error_code = $2,
|
||
error_message = $3,
|
||
result = coalesce(result, '{}'::jsonb) || jsonb_strip_nulls(jsonb_build_object(
|
||
'failure_source', $4::text, 'failure_stage', $5::text,
|
||
'failure_detail', $6::text, 'provider_error_raw', $7::text)),
|
||
completed_at = now()
|
||
WHERE id = $1 AND status IN ('queued', 'running')`,
|
||
[id, code, message, source, stage, detail, providerErrorRaw],
|
||
);
|
||
});
|
||
}
|