Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

17.7 KB
Raw Blame
import type {EventBus, IEventBusSafeEmitResult} from "../../plugin/EventBusCore";
import {emitWithErrors, eventBusHas, hasPluginSubscriber} from "../../plugin/EventBusCore";
import {genUUID} from "../../util/genID";

export interface IAssetUploadEventContext {
    source: TAssetUploadSource;
    target: TAssetUploadTarget;
    position?: IAssetUploadPosition;
    requiredFileCount?: number;
    allowedInputKinds?: Array<IAssetUploadInput["kind"]>;
}

export interface IAssetUploadTask {
    readonly requestId: string;
    readonly signal: AbortSignal;
    input: IAssetUploadInput;
    abort(reason: Error): void;
    startUpload(cancelOnEditorDestroy?: boolean): void;
    complete(result: Omit<IAssetUploadResult, "requestId" | "input">): boolean;
}

export type TPreparedAssetUpload = {
    state: "ready";
    task: IAssetUploadTask;
} | {
    state: "canceled" | "failed";
    task: IAssetUploadTask;
    error?: string;
};

interface IAssetUploadPlugin {
    name?: string;
    eventBus: EventBus<IBeforeUploadAssetsDetail>;
}

class AssetUploadCanceledError extends Error {
}

class AssetUploadTimeoutError extends Error {
}

export const ASSET_UPLOAD_PLUGIN_TIMEOUT = 120_000;

const waitingTasksByProtyle = new WeakMap<IProtyle, Set<AssetUploadTask>>();
const waitingTasksByPlugin = new WeakMap<IAssetUploadPlugin, Set<AssetUploadTask>>();
const activeTasksByProtyle = new WeakMap<IProtyle, Set<AssetUploadTask>>();
const completionTasksByPlugin = new WeakMap<IAssetUploadPlugin, Set<AssetUploadTask>>();
const unloadingPlugins = new WeakSet<IAssetUploadPlugin>();

const genRequestId = () => typeof globalThis.crypto.randomUUID === "function" ?
    globalThis.crypto.randomUUID() : genUUID();

const cloneInput = (input: IAssetUploadInput): IAssetUploadInput => {
    if (input.kind === "files") {
        return {kind: "files", files: Array.from(input.files)};
    }
    return {kind: "local-files", files: input.files.map(file => ({...file}))};
};

const cloneResult = (result: IAssetUploadResult): IAssetUploadResult => {
    const cloned: IAssetUploadResult = {
        ...result,
        input: cloneInput(result.input),
    };
    if (result.acceptedInput) {
        cloned.acceptedInput = cloneInput(result.acceptedInput);
    }
    if (result.rejected) {
        cloned.rejected = result.rejected.map(item => ({...item, reasons: Array.from(item.reasons)}));
    }
    if (result.succFiles) {
        cloned.succFiles = result.succFiles.map(item => ({...item}));
    }
    if (result.failedFiles) {
        cloned.failedFiles = result.failedFiles.map(item => ({...item}));
    }
    if (result.succMap) {
        cloned.succMap = {...result.succMap};
    }
    if (result.errFiles) {
        cloned.errFiles = Array.from(result.errFiles);
    }
    return cloned;
};

const validateAssetUploadInput = (input: unknown) => {
    if (!input || typeof input !== "object") {
        return "input must be an object";
    }
    const value = input as IAssetUploadInput;
    if (!Array.isArray(value.files)) {
        return "input.files must be an array";
    }
    if (value.kind === "files") {
        const invalidIndex = value.files.findIndex(file => !(file instanceof File) &&
            Object.prototype.toString.call(file) !== "[object File]");
        return invalidIndex === -1 ? "" : `input.files[${invalidIndex}] must be a File`;
    }
    if (value.kind === "local-files") {
        for (let index = 0; index < value.files.length; index++) {
            const file = value.files[index];
            if (!file || typeof file !== "object") {
                return `input.files[${index}] must be an object`;
            }
            if (typeof file.path !== "string" || file.path.length === 0) {
                return `input.files[${index}].path must be a non-empty string`;
            }
            if (file.size !== null && (typeof file.size !== "number" || !Number.isFinite(file.size) || file.size < 0)) {
                return `input.files[${index}].size must be null or a non-negative finite number`;
            }
            if (file.isDir !== undefined && typeof file.isDir !== "boolean") {
                return `input.files[${index}].isDir must be a boolean`;
            }
        }
        return "";
    }
    return "input.kind must be files or local-files";
};

const getErrorMessage = (error: unknown) => {
    if (error instanceof Error && error.message) {
        return error.message;
    }
    return typeof error === "string" ? error : "";
};

const getPluginLabel = (plugin: IAssetUploadPlugin, index: number) => plugin.name || `#${index + 1}`;

const validateTargetInput = (input: IAssetUploadInput, context: IAssetUploadEventContext) => {
    if (context.allowedInputKinds && !context.allowedInputKinds.includes(input.kind)) {
        return `this upload only accepts ${context.allowedInputKinds.join(" or ")} input`;
    }
    if (context.requiredFileCount !== undefined && input.files.length !== context.requiredFileCount) {
        if (context.target === "background") {
            return "background uploads require exactly one file";
        }
        return `this upload requires exactly ${context.requiredFileCount} file(s)`;
    }
    return "";
};

class AssetUploadTask implements IAssetUploadTask {
    public readonly requestId: string;
    public readonly signal: AbortSignal;
    public input: IAssetUploadInput;
    private completed = false;
    private readonly abortController = new AbortController();
    private readonly callbacks: Array<{
        plugin: IAssetUploadPlugin;
        callback: (result: IAssetUploadResult) => any;
    }> = [];
    private readonly protyle?: IProtyle;
    private waitingPlugins: IAssetUploadPlugin[] = [];
    private uploadStarted = false;

    constructor(input: IAssetUploadInput, requestId: string, protyle?: IProtyle) {
        this.input = cloneInput(input);
        this.requestId = requestId;
        this.protyle = protyle;
        this.signal = this.abortController.signal;
    }

    public addCompleteCallback(plugin: IAssetUploadPlugin, callback: (result: IAssetUploadResult) => void) {
        this.callbacks.push({plugin, callback});
        let tasks = completionTasksByPlugin.get(plugin);
        if (!tasks) {
            tasks = new Set();
            completionTasksByPlugin.set(plugin, tasks);
        }
        tasks.add(this);
    }

    public removeCompleteCallbacks(plugin: IAssetUploadPlugin) {
        for (let index = this.callbacks.length - 1; index >= 0; index--) {
            if (this.callbacks[index].plugin === plugin) {
                this.callbacks.splice(index, 1);
            }
        }
        completionTasksByPlugin.get(plugin)?.delete(this);
    }

    public startWaiting(plugins: IAssetUploadPlugin[]) {
        this.stopWaiting();
        this.waitingPlugins = plugins;
        if (this.protyle) {
            let protyleTasks = waitingTasksByProtyle.get(this.protyle);
            if (!protyleTasks) {
                protyleTasks = new Set();
                waitingTasksByProtyle.set(this.protyle, protyleTasks);
            }
            protyleTasks.add(this);
        }
        plugins.forEach(plugin => {
            let pluginTasks = waitingTasksByPlugin.get(plugin);
            if (!pluginTasks) {
                pluginTasks = new Set();
                waitingTasksByPlugin.set(plugin, pluginTasks);
            }
            pluginTasks.add(this);
        });
    }

    public stopWaiting() {
        if (this.protyle) {
            waitingTasksByProtyle.get(this.protyle)?.delete(this);
        }
        this.waitingPlugins.forEach(plugin => waitingTasksByPlugin.get(plugin)?.delete(this));
        this.waitingPlugins = [];
    }

    public startUpload(cancelOnEditorDestroy = false) {
        if (this.uploadStarted || !this.protyle) {
            return;
        }
        this.uploadStarted = true;
        if (!cancelOnEditorDestroy) {
            return;
        }
        let tasks = activeTasksByProtyle.get(this.protyle);
        if (!tasks) {
            tasks = new Set();
            activeTasksByProtyle.set(this.protyle, tasks);
        }
        tasks.add(this);
    }

    public abort(reason: Error) {
        if (!this.signal.aborted) {
            this.abortController.abort(reason);
        }
    }

    public complete(result: Omit<IAssetUploadResult, "requestId" | "input">) {
        if (this.completed) {
            return false;
        }
        this.completed = true;
        this.stopWaiting();
        if (this.protyle) {
            activeTasksByProtyle.get(this.protyle)?.delete(this);
        }
        const detail: IAssetUploadResult = {
            ...result,
            requestId: this.requestId,
            input: cloneInput(this.input),
        };
        if (result.acceptedInput) {
            detail.acceptedInput = cloneInput(result.acceptedInput);
        }
        if (result.rejected) {
            detail.rejected = result.rejected.map(item => ({...item, reasons: Array.from(item.reasons)}));
        }
        const callbacks = this.callbacks.splice(0);
        callbacks.forEach(item => completionTasksByPlugin.get(item.plugin)?.delete(this));
        callbacks.forEach(item => {
            try {
                const callbackResult = item.callback(cloneResult(detail));
                if (callbackResult && typeof callbackResult.then === "function") {
                    void Promise.resolve(callbackResult).catch(error => console.error(error));
                }
            } catch (error) {
                console.error(error);
            }
        });
        return true;
    }
}

const cancelWaitingTasks = (tasks: Set<AssetUploadTask> | undefined, reason: string) => {
    Array.from(tasks || []).forEach(task => task.abort(new AssetUploadCanceledError(reason)));
};

export const cancelAssetUploads = (protyle: IProtyle) => {
    cancelWaitingTasks(waitingTasksByProtyle.get(protyle), "The editor was destroyed");
    cancelWaitingTasks(activeTasksByProtyle.get(protyle), "The editor was destroyed");
};

export const cancelAssetUploadsByPlugin = (plugin: IAssetUploadPlugin) => {
    unloadingPlugins.add(plugin);
    Array.from(completionTasksByPlugin.get(plugin) || []).forEach(task => task.removeCompleteCallbacks(plugin));
    cancelWaitingTasks(waitingTasksByPlugin.get(plugin), `Plugin ${plugin.name || ""} was unloaded`.trim());
};

const waitForDecision = (response: PromiseLike<IAssetUploadDecision>, task: AssetUploadTask,
                         pluginLabel: string, timeout: number) => {
    return new Promise<IAssetUploadDecision>((resolve, reject) => {
        let settled = false;
        const finish = (callback: (value: any) => void, value: any) => {
            if (settled) {
                return;
            }
            settled = true;
            clearTimeout(timeoutId);
            task.signal.removeEventListener("abort", onAbort);
            callback(value);
        };
        const onAbort = () => finish(reject, task.signal.reason instanceof Error ? task.signal.reason :
            new AssetUploadCanceledError("The upload was canceled"));
        const timeoutId = setTimeout(() => {
            task.abort(new AssetUploadTimeoutError(`Plugin ${pluginLabel} asset processing timed out`));
        }, timeout);
        task.signal.addEventListener("abort", onAbort, {once: true});
        if (task.signal.aborted) {
            onAbort();
            return;
        }
        Promise.resolve(response).then(value => finish(resolve, value), error => finish(reject, error));
    });
};

export const prepareAssetUpload = (options: {
    plugins: IAssetUploadPlugin[];
    protyle?: IProtyle;
    input: IAssetUploadInput;
    context: IAssetUploadEventContext;
    requestId?: string;
    timeout?: number;
}): TPreparedAssetUpload | Promise<TPreparedAssetUpload> => {
    const task = new AssetUploadTask(options.input, options.requestId || genRequestId(), options.protyle);
    const timeout = options.timeout ?? ASSET_UPLOAD_PLUGIN_TIMEOUT;
    const context = {
        ...options.context,
        requiredFileCount: options.context.requiredFileCount ??
            (options.context.target === "background" ? 1 : undefined),
    };
    const fail = (error: unknown): TPreparedAssetUpload => {
        const errorMessage = getErrorMessage(error);
        task.abort(error instanceof Error ? error : new Error(errorMessage));
        task.complete({status: "failed", error: errorMessage});
        return {state: "failed", task, error: errorMessage};
    };
    const cancel = (reason = "The upload was canceled"): TPreparedAssetUpload => {
        task.abort(new AssetUploadCanceledError(reason));
        task.complete({status: "canceled"});
        return {state: "canceled", task};
    };
    const initialValidationError = validateAssetUploadInput(task.input) || validateTargetInput(task.input, context);
    if (initialValidationError) {
        return fail(initialValidationError);
    }
    if (!hasPluginSubscriber("before-upload-assets")) {
        return {state: "ready", task};
    }
    const plugins = Array.from(options.plugins).filter(plugin => !unloadingPlugins.has(plugin) &&
        eventBusHas(plugin.eventBus, "before-upload-assets"));
    if (plugins.length === 0) {
        return {state: "ready", task};
    }
    const processPlugin = (index: number): TPreparedAssetUpload | Promise<TPreparedAssetUpload> => {
        if (task.signal.aborted) {
            const reason = task.signal.reason instanceof Error ? task.signal.reason.message : "The upload was canceled";
            return cancel(reason);
        }
        if (index >= plugins.length) {
            task.stopWaiting();
            return {state: "ready", task};
        }
        const plugin = plugins[index];
        if (unloadingPlugins.has(plugin)) {
            return processPlugin(index + 1);
        }
        task.startWaiting(plugins.slice(index));
        const pluginLabel = getPluginLabel(plugin, index);
        let response: PromiseLike<IAssetUploadDecision> | undefined;
        let responseClaimed = false;
        let responseError = "";
        let acceptingRegistrations = true;
        let emitResult: IEventBusSafeEmitResult;
        const discardResponse = () => {
            if (response) {
                void Promise.resolve(response).catch(error => console.error(error));
            }
        };
        try {
            emitResult = emitWithErrors(plugin.eventBus, "before-upload-assets", {
                requestId: task.requestId,
                protyle: options.protyle,
                source: context.source,
                target: context.target,
                position: context.position ? {...context.position} : undefined,
                requiredFileCount: context.requiredFileCount,
                allowedInputKinds: context.allowedInputKinds ? Array.from(context.allowedInputKinds) : undefined,
                input: cloneInput(task.input),
                signal: task.signal,
                respondWith(value) {
                    if (!acceptingRegistrations) {
                        console.error(new Error(`Plugin ${pluginLabel} must call respondWith synchronously`));
                        return;
                    }
                    if (responseClaimed) {
                        responseError = `Plugin ${pluginLabel} called respondWith more than once`;
                        return;
                    }
                    responseClaimed = true;
                    response = Promise.resolve(value);
                },
                onComplete(callback) {
                    if (!acceptingRegistrations) {
                        console.error(new Error(`Plugin ${pluginLabel} must register onComplete synchronously`));
                        return;
                    }
                    if (unloadingPlugins.has(plugin)) {
                        return;
                    }
                    task.addCompleteCallback(plugin, callback);
                },
            });
        } catch (error) {
            acceptingRegistrations = false;
            discardResponse();
            return fail(error);
        }
        acceptingRegistrations = false;
        if (Object.prototype.hasOwnProperty.call(emitResult, "error")) {
            discardResponse();
            return fail(new Error(`Plugin ${pluginLabel} failed during before-upload-assets: ${getErrorMessage(emitResult.error)}`));
        }
        if (emitResult.defaultPrevented) {
            discardResponse();
            return fail(new Error(`Plugin ${pluginLabel} must use respondWith to replace or cancel an asset upload`));
        }
        if (responseError) {
            discardResponse();
            return fail(responseError);
        }
        if (emitResult.hasAsyncListener && !responseClaimed) {
            return fail(new Error(`Plugin ${pluginLabel} must call respondWith synchronously before awaiting`));
        }
        if (!response) {
            return processPlugin(index + 1);
        }
        return waitForDecision(response, task, pluginLabel, timeout).then(decision => {
            if (decision?.action === "cancel") {
                return cancel();
            }
            if (decision?.action !== "replace") {
                throw new Error(`Plugin ${pluginLabel} returned an invalid action`);
            }
            const validationError = validateAssetUploadInput(decision.input);
            if (validationError) {
                throw new Error(`Plugin ${pluginLabel} returned invalid input: ${validationError}`);
            }
            const targetValidationError = validateTargetInput(decision.input, context);
            if (targetValidationError) {
                throw new Error(`Plugin ${pluginLabel} returned invalid input: ${targetValidationError}`);
            }
            task.input = cloneInput(decision.input);
            return processPlugin(index + 1);
        }).catch(error => error instanceof AssetUploadCanceledError ? cancel(error.message) : fail(error));
    };
    return processPlugin(0);
};