@gaoding/cli 0.0.0 → 1.0.0-alpha.25

package/dist/src/features/dam/use-cases.js

@@ -0,0 +1,470 @@
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { DamOperationUnconfirmedError } from "./operation-executor.js";
+export class DamInputError extends Error {
+    constructor() {
+        super("DAM 输入不可用。");
+        this.name = "DamInputError";
+    }
+}
+export class DamRepositoryNotFoundError extends Error {
+    constructor() {
+        super("当前组织没有可用的 DAM 资源库。");
+        this.name = "DamRepositoryNotFoundError";
+    }
+}
+export { DamOperationUnconfirmedError } from "./operation-executor.js";
+function invalid() {
+    throw new DamInputError();
+}
+function nonblank(value) {
+    return value !== undefined && value.trim() !== "";
+}
+function assertPageSize(value) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 1 || value > 100))
+        invalid();
+}
+function assertPage(value) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 1))
+        invalid();
+}
+function assertOptionalNonblank(value) {
+    if (value !== undefined && !nonblank(value))
+        invalid();
+}
+function assertAssetId(value) {
+    if (value.trim() === "" || /^https?:\/\//iu.test(value))
+        invalid();
+}
+function assertRepositorySelection(input) {
+    if (input.repositoryId !== undefined && !nonblank(input.repositoryId))
+        invalid();
+    if (input.repositoryId !== undefined && input.allRepositories === true)
+        invalid();
+}
+function searchRequest(input, keyword, repositoryIds) {
+    return {
+        keyword,
+        repositoryIds,
+        includeChildFolder: input.includeChildFolder ?? true,
+        pageSize: input.pageSize ?? 20,
+        ...(input.folderId === undefined ? {} : { folderId: input.folderId }),
+        ...(input.type === undefined ? {} : { type: input.type }),
+        ...(input.assetFormats === undefined ? {} : { assetFormats: [...input.assetFormats] }),
+        ...(input.tagIds === undefined ? {} : { tagIds: [...input.tagIds] }),
+        ...(input.cursor === undefined ? {} : { cursor: input.cursor })
+    };
+}
+export function createDamUseCases(dependencies) {
+    const validate = dependencies.validate;
+    async function entryTitle(input) {
+        if (input.kind === "asset") {
+            return (await dependencies.api.getAsset({
+                assetId: input.entryId,
+                access: input.access,
+                signal: input.signal
+            })).title;
+        }
+        return (await dependencies.api.getFolder({
+            folderId: input.entryId,
+            repositoryId: input.repositoryId,
+            access: input.access,
+            signal: input.signal
+        })).title;
+    }
+    async function entryLocation(input) {
+        if (input.kind === "asset") {
+            const detail = await dependencies.api.getAsset({
+                assetId: input.entryId,
+                access: input.access,
+                signal: input.signal
+            });
+            return {
+                ...(detail.repository_id === undefined ? {} : { repositoryId: detail.repository_id }),
+                ...(detail.folder_id === undefined ? {} : { folderId: detail.folder_id })
+            };
+        }
+        const detail = await dependencies.api.getFolder({
+            folderId: input.entryId,
+            repositoryId: input.repositoryId,
+            access: input.access,
+            signal: input.signal
+        });
+        return { repositoryId: detail.repository_id, folderId: detail.folder_id };
+    }
+    function assertEntryOperationInput(input) {
+        assertAssetId(input.entry_id);
+        if (input.kind !== "asset" && input.kind !== "folder")
+            invalid();
+        if (!nonblank(input.targetFolderId))
+            invalid();
+        assertOptionalNonblank(input.repositoryId);
+        assertOptionalNonblank(input.targetRepositoryId);
+        if (input.kind === "folder" && input.entry_id === input.targetFolderId)
+            invalid();
+    }
+    async function entryOperation(input) {
+        assertEntryOperationInput(input.request);
+        const [sourceRepository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+            ...(input.request.repositoryId === undefined
+                ? {}
+                : { repositoryId: input.request.repositoryId })
+        }, input.access, input.signal)));
+        if (sourceRepository === undefined)
+            throw new DamRepositoryNotFoundError();
+        const targetRepositoryId = input.request.targetRepositoryId ?? sourceRepository.id;
+        const locationRequest = {
+            entryId: input.request.entry_id,
+            kind: input.request.kind,
+            repositoryId: sourceRepository.id,
+            access: input.access,
+            signal: input.signal
+        };
+        const current = await dependencies.telemetry.stage("resolve", () => (entryLocation(locationRequest)));
+        if (input.operation === "move"
+            && current.repositoryId === targetRepositoryId
+            && current.folderId === input.request.targetFolderId)
+            invalid();
+        const execution = await dependencies.telemetry.stage("wait", () => (dependencies.operations.execute({
+            operation: input.operation,
+            submit: () => dependencies.telemetry.stage("submit", () => (dependencies.api.submitEntryOperation({
+                entryId: input.request.entry_id,
+                kind: input.request.kind,
+                operation: input.operation,
+                sourceRepositoryId: sourceRepository.id,
+                targetRepositoryId,
+                targetFolderId: input.request.targetFolderId,
+                access: input.access,
+                signal: input.signal
+            }))),
+            getTask: (taskId, signal) => dependencies.api.getOperationTask({
+                taskId,
+                access: input.access,
+                signal
+            }),
+            ...(input.operation === "copy"
+                ? {
+                    inspectResult: (taskId, signal) => (dependencies.api.getOperationChildren({
+                        taskId,
+                        access: input.access,
+                        signal
+                    }))
+                }
+                : {}),
+            signal: input.signal
+        })));
+        return {
+            sourceRepositoryId: sourceRepository.id,
+            targetRepositoryId,
+            targetFolderId: input.request.targetFolderId,
+            ...(execution.copied_entry_id === undefined
+                ? {}
+                : { copiedEntryId: execution.copied_entry_id })
+        };
+    }
+    async function resolveRepositories(input, access, signal) {
+        assertRepositorySelection(input);
+        if (input.repositoryId !== undefined)
+            return [{ id: input.repositoryId }];
+        signal.throwIfAborted();
+        const available = await dependencies.repositories.list({ access, signal });
+        signal.throwIfAborted();
+        if (available.length === 0)
+            throw new DamRepositoryNotFoundError();
+        const selected = input.allRepositories === true
+            ? available
+            : [available.find((repository) => repository.is_default) ?? available[0]];
+        return selected.map((repository) => ({
+            id: repository.repository_id,
+            ...(repository.name === undefined ? {} : { name: repository.name })
+        }));
+    }
+    return {
+        async repositoryList({ access, signal }) {
+            signal.throwIfAborted();
+            const repositories = await dependencies.repositories.list({ access, signal });
+            signal.throwIfAborted();
+            if (repositories.length === 0)
+                throw new DamRepositoryNotFoundError();
+            const result = { repositories };
+            validate.repositoryList(result);
+            return result;
+        },
+        async list({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertPageSize(input.pageSize);
+            const repositories = await dependencies.telemetry.stage("repository", () => (resolveRepositories(input, access, signal)));
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.search({
+                    ...searchRequest(input, "", repositories.map((repository) => repository.id)),
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.list(result);
+                return result;
+            });
+        },
+        async search({ input, access, signal }) {
+            signal.throwIfAborted();
+            if (!nonblank(input.query))
+                invalid();
+            assertPageSize(input.pageSize);
+            const repositories = await dependencies.telemetry.stage("repository", () => (resolveRepositories(input, access, signal)));
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.search({
+                    ...searchRequest(input, input.query, repositories.map((repository) => repository.id)),
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.search(result);
+                return result;
+            });
+        },
+        async folderList({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertOptionalNonblank(input.parentId);
+            assertOptionalNonblank(input.query);
+            assertPage(input.page);
+            assertPageSize(input.pageSize);
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.listFolders({
+                    repositoryId: repository.id,
+                    parentId: input.parentId ?? "0",
+                    page: input.page ?? 1,
+                    pageSize: input.pageSize ?? 20,
+                    ...(input.query === undefined ? {} : { query: input.query }),
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.folderList(result);
+                return result;
+            });
+        },
+        async tagList({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertOptionalNonblank(input.query);
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.listTags({
+                    repositoryId: repository.id,
+                    ...(input.query === undefined ? {} : { query: input.query }),
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.tagList(result);
+                return result;
+            });
+        },
+        async download({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertAssetId(input.asset_id);
+            assertOptionalNonblank(input.outputDir);
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            const detail = await dependencies.telemetry.stage("resolve", () => (dependencies.api.getAsset({ assetId: input.asset_id, access, signal })));
+            signal.throwIfAborted();
+            const urls = await dependencies.telemetry.stage("download", () => (dependencies.api.getDownloadUrls({
+                assetId: input.asset_id,
+                repositoryId: repository.id,
+                access,
+                signal
+            })));
+            signal.throwIfAborted();
+            const files = await dependencies.telemetry.stage("persist", () => (dependencies.downloader.download({
+                urls,
+                ...(detail.title === undefined ? {} : { fallbackTitle: detail.title }),
+                ...(detail.format === undefined ? {} : { fallbackFormat: detail.format }),
+                outputDirectory: input.outputDir ?? ".",
+                signal
+            })));
+            signal.throwIfAborted();
+            const result = { asset_id: input.asset_id, files };
+            validate.download(result);
+            return result;
+        },
+        async rename({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertAssetId(input.entry_id);
+            if (input.kind !== "asset" && input.kind !== "folder")
+                invalid();
+            if (!nonblank(input.title) || input.title.length > 100)
+                invalid();
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            const request = {
+                entryId: input.entry_id,
+                kind: input.kind,
+                repositoryId: repository.id,
+                access,
+                signal
+            };
+            const currentTitle = await dependencies.telemetry.stage("rename", async () => {
+                const title = await entryTitle(request);
+                signal.throwIfAborted();
+                if (title?.trim() !== input.title.trim()) {
+                    await dependencies.api.renameEntry({
+                        ...request,
+                        repositoryId: repository.id,
+                        title: input.title
+                    });
+                }
+                return title;
+            });
+            if (currentTitle?.trim() === input.title.trim()) {
+                const result = {
+                    entry_id: input.entry_id,
+                    kind: input.kind,
+                    repository_id: repository.id,
+                    title: currentTitle
+                };
+                validate.rename(result);
+                return result;
+            }
+            await dependencies.telemetry.stage("verify", async () => {
+                for (let attempt = 0; attempt <= 30; attempt += 1) {
+                    signal.throwIfAborted();
+                    if (await entryTitle(request) === input.title)
+                        return;
+                    if (attempt < 30)
+                        await dependencies.sleep(2_000, signal);
+                }
+                throw new DamOperationUnconfirmedError("rename");
+            });
+            const result = {
+                entry_id: input.entry_id,
+                kind: input.kind,
+                repository_id: repository.id,
+                title: input.title
+            };
+            validate.rename(result);
+            return result;
+        },
+        async move({ input, access, signal }) {
+            signal.throwIfAborted();
+            const operation = await entryOperation({ operation: "move", request: input, access, signal });
+            await dependencies.telemetry.stage("verify", async () => {
+                for (let attempt = 0; attempt <= 30; attempt += 1) {
+                    signal.throwIfAborted();
+                    const location = await entryLocation({
+                        entryId: input.entry_id,
+                        kind: input.kind,
+                        repositoryId: operation.targetRepositoryId,
+                        access,
+                        signal
+                    });
+                    if (location.repositoryId === operation.targetRepositoryId
+                        && location.folderId === operation.targetFolderId)
+                        return;
+                    if (attempt < 30)
+                        await dependencies.sleep(2_000, signal);
+                }
+                throw new DamOperationUnconfirmedError("move");
+            });
+            const result = {
+                entry_id: input.entry_id,
+                kind: input.kind,
+                repository_id: operation.targetRepositoryId,
+                folder_id: operation.targetFolderId
+            };
+            await dependencies.telemetry.stage("output", () => { validate.move(result); });
+            return result;
+        },
+        async copy({ input, access, signal }) {
+            signal.throwIfAborted();
+            const operation = await entryOperation({ operation: "copy", request: input, access, signal });
+            const result = {
+                source_entry_id: input.entry_id,
+                kind: input.kind,
+                repository_id: operation.targetRepositoryId,
+                folder_id: operation.targetFolderId,
+                ...(operation.copiedEntryId === undefined
+                    ? {}
+                    : { copied_entry_id: operation.copiedEntryId })
+            };
+            await dependencies.telemetry.stage("output", () => { validate.copy(result); });
+            return result;
+        },
+        async get({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertAssetId(input.asset_id);
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.getAsset({
+                    assetId: input.asset_id,
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.get(result);
+                return result;
+            });
+        },
+        async upload({ input, access, signal }) {
+            signal.throwIfAborted();
+            if (!nonblank(input.file))
+                invalid();
+            const file = await dependencies.telemetry.stage("inspect", () => (dependencies.storage.inspect({
+                url: pathToFileURL(resolve(process.cwd(), input.file)).href,
+                ...(input.allowSensitivePath === undefined
+                    ? {}
+                    : { allowSensitivePath: input.allowSensitivePath })
+            }, signal)));
+            signal.throwIfAborted();
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            const result = await dependencies.uploader.upload({
+                input,
+                file,
+                repository,
+                access,
+                signal
+            });
+            signal.throwIfAborted();
+            validate.upload(result);
+            return result;
+        },
+        async delete({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertAssetId(input.asset_id);
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            const request = {
+                repositoryId: repository.id,
+                assetId: input.asset_id,
+                access,
+                signal
+            };
+            await dependencies.telemetry.stage("recycle", () => dependencies.api.recycle(request));
+            signal.throwIfAborted();
+            if (input.permanent === true) {
+                await dependencies.telemetry.stage("delete", () => dependencies.api.deleteRecycled(request));
+            }
+            signal.throwIfAborted();
+            validate.delete(null);
+        }
+    };
+}

package/dist/src/features/editor/bridge-client.js

@@ -0,0 +1,109 @@
+export class EditorBridgeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "EditorBridgeError";
+        this.code = code;
+    }
+}
+export class EditorBridgeUnavailableError extends Error {
+    constructor() {
+        super("Editor Bridge is unavailable.");
+        this.name = "EditorBridgeUnavailableError";
+    }
+}
+export function createEditorBridgeClient(options) {
+    const fetch = options.fetch ?? globalThis.fetch;
+    const baseUrl = `http://127.0.0.1:${options.state.port}`;
+    return {
+        async health(signal) {
+            const value = await request("/health", "GET", undefined, signal);
+            if (!isRecord(value) ||
+                !hasExactKeys(value, ["status", "pageConnected", "protocolVersion"]) ||
+                value.status !== "ok" ||
+                typeof value.pageConnected !== "boolean" ||
+                typeof value.protocolVersion !== "number") {
+                throw invalidResponse();
+            }
+            return {
+                status: "ok",
+                pageConnected: value.pageConnected,
+                protocolVersion: value.protocolVersion
+            };
+        },
+        async rpc(method, payload, signal) {
+            const value = await request("/rpc", "POST", { method, ...(payload === undefined ? {} : { payload }) }, signal);
+            if (!isRecord(value) ||
+                (!hasExactKeys(value, []) && !hasExactKeys(value, ["result"]))) {
+                throw invalidResponse();
+            }
+            return value.result;
+        },
+        async disconnect(signal) {
+            const value = await request("/disconnect", "POST", {}, signal);
+            if (!isRecord(value) ||
+                !hasExactKeys(value, ["status"]) ||
+                value.status !== "disconnected") {
+                throw invalidResponse();
+            }
+        }
+    };
+    async function request(pathname, method, body, signal) {
+        signal.throwIfAborted();
+        let response;
+        try {
+            response = await fetch(`${baseUrl}${pathname}`, {
+                method,
+                headers: {
+                    Authorization: `Bearer ${options.state.token}`,
+                    ...(body === undefined ? {} : { "Content-Type": "application/json" })
+                },
+                redirect: "error",
+                signal,
+                ...(body === undefined ? {} : { body: JSON.stringify(body) })
+            });
+        }
+        catch {
+            signal.throwIfAborted();
+            throw new EditorBridgeUnavailableError();
+        }
+        let value;
+        try {
+            value = await response.json();
+        }
+        catch {
+            throw invalidResponse();
+        }
+        if (!response.ok) {
+            const error = readStructuredError(value);
+            if (!error)
+                throw invalidResponse();
+            throw new EditorBridgeError(error.code, error.message);
+        }
+        return value;
+    }
+}
+function readStructuredError(value) {
+    if (!isRecord(value) || !isRecord(value.error))
+        return null;
+    const { code, message } = value.error;
+    if (typeof code !== "string" ||
+        !/^[A-Z][A-Z0-9_]*$/.test(code) ||
+        typeof message !== "string" ||
+        message.trim().length === 0) {
+        return null;
+    }
+    return { code, message };
+}
+function invalidResponse() {
+    return new EditorBridgeError("EDITOR_BRIDGE_INVALID_RESPONSE", "Editor Bridge 返回了无效响应。");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length &&
+        actual.every((key, index) => key === expected[index]);
+}