@gaoding/cli 0.0.0 → 1.0.0-alpha.25

package/dist/src/features/dam/dam-api-adapter.js

@@ -0,0 +1,562 @@
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { RemoteProtocolError } from "../../platform/remote-protocol.js";
+import { parseSafeRemoteAssetUrl, UrlSafetyError } from "../../platform/url-safety.js";
+import { projectDamAssetDetail, projectDamAssetSummary } from "./asset-projection.js";
+export class DamAssetNotFoundError extends Error {
+    constructor() {
+        super("DAM 素材不存在。");
+        this.name = "DamAssetNotFoundError";
+    }
+}
+export class DamAssetNotDownloadableError extends Error {
+    constructor() {
+        super("该 DAM 素材当前不可下载。");
+        this.name = "DamAssetNotDownloadableError";
+    }
+}
+export class DamFolderNotFoundError extends Error {
+    constructor() {
+        super("DAM 文件夹不存在。");
+        this.name = "DamFolderNotFoundError";
+    }
+}
+const contentFormats = {
+    image: ["gdpic", "gdimage"],
+    video: ["gdvideo"],
+    audio: ["gdaudio"],
+    font: ["gdfont"],
+    template: ["gdtemplate"],
+    file: ["gdfile", "gdimage", "gdslide"]
+};
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function nonblank(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function nonnegativeInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+const permissions = new Set(["OWNER", "MANAGE", "EDIT", "USE", "READ"]);
+function folderPermission(value) {
+    return typeof value === "string"
+        && permissions.has(value)
+        ? value
+        : undefined;
+}
+function optionalString(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const projected = String(value);
+    return projected.trim() === "" ? undefined : projected;
+}
+function folderRows(value) {
+    if (!Array.isArray(value))
+        throw new RemoteProtocolError();
+    return value.flatMap((candidate) => {
+        const item = record(candidate);
+        const folderId = nonblank(item?.id);
+        const title = nonblank(item?.title);
+        const parentId = nonblank(item?.parent_id);
+        const repositoryId = nonblank(item?.repository_id);
+        if (folderId === undefined
+            || title === undefined
+            || parentId === undefined
+            || repositoryId === undefined)
+            return [];
+        const permissionCode = folderPermission(item?.permission_code);
+        const path = nonblank(item?.path);
+        const createdAt = optionalString(item?.created_at);
+        const updatedAt = optionalString(item?.updated_at);
+        return [{
+                folder_id: folderId,
+                title,
+                parent_id: parentId,
+                repository_id: repositoryId,
+                ...(permissionCode === undefined ? {} : { permission_code: permissionCode }),
+                child_folder_count: nonnegativeInteger(item?.child_folder_count),
+                asset_count: nonnegativeInteger(item?.content_count),
+                ...(path === undefined ? {} : { path }),
+                ...(createdAt === undefined ? {} : { created_at: createdAt }),
+                ...(updatedAt === undefined ? {} : { updated_at: updatedAt })
+            }];
+    });
+}
+function folderPagination(headers) {
+    const raw = headers.get("x-pagination");
+    if (raw === null)
+        throw new RemoteProtocolError();
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new RemoteProtocolError();
+    }
+    const pagination = record(value);
+    const page = pagination?.num;
+    const pageSize = pagination?.size;
+    const total = pagination?.total;
+    if (!Number.isInteger(page) || page < 1
+        || !Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100
+        || !Number.isInteger(total) || total < 0) {
+        throw new RemoteProtocolError();
+    }
+    return { page: page, pageSize: pageSize, total: total };
+}
+function tagRows(value) {
+    if (!Array.isArray(value))
+        throw new RemoteProtocolError();
+    return value.flatMap((candidate) => {
+        const item = record(candidate);
+        const tagId = nonblank(item?.id);
+        const name = nonblank(item?.name);
+        if (tagId === undefined || name === undefined)
+            return [];
+        const groupId = nonblank(item?.group_id);
+        return [{
+                tag_id: tagId,
+                name,
+                ...(groupId === undefined ? {} : { group_id: groupId }),
+                asset_count: nonnegativeInteger(item?.file_count)
+            }];
+    });
+}
+function downloadUrls(value) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new RemoteProtocolError();
+    }
+    const urls = value.filter((item) => (typeof item === "string" && item.trim() !== ""));
+    if (urls.length === 0)
+        throw new DamAssetNotDownloadableError();
+    for (const value of urls) {
+        try {
+            const url = parseSafeRemoteAssetUrl(value);
+            if (url.protocol !== "https:")
+                throw new UrlSafetyError();
+        }
+        catch (error) {
+            if (error instanceof UrlSafetyError)
+                throw new RemoteProtocolError();
+            throw error;
+        }
+    }
+    return urls;
+}
+function folderDetail(response) {
+    for (const source of responseRecords(response).reverse()) {
+        const entryId = nonblank(source.id);
+        const title = nonblank(source.title);
+        const repositoryId = nonblank(source.repository_id);
+        const parentId = nonblank(source.parent_id);
+        if (entryId !== undefined
+            && title !== undefined
+            && repositoryId !== undefined
+            && parentId !== undefined) {
+            return {
+                entry_id: entryId,
+                kind: "folder",
+                title,
+                repository_id: repositoryId,
+                folder_id: parentId
+            };
+        }
+    }
+    throw new RemoteProtocolError();
+}
+function operationSubmission(response) {
+    const root = record(response);
+    const source = record(root?.data) ?? root;
+    if (source === undefined)
+        throw new RemoteProtocolError();
+    const rawTaskId = source.task_id;
+    let taskId;
+    if (rawTaskId !== undefined && rawTaskId !== null) {
+        if (typeof rawTaskId === "number") {
+            if (!Number.isSafeInteger(rawTaskId) || rawTaskId < 0)
+                throw new RemoteProtocolError();
+            if (rawTaskId !== 0)
+                taskId = String(rawTaskId);
+        }
+        else if (typeof rawTaskId === "string" && rawTaskId.trim() !== "") {
+            if (rawTaskId.trim() !== "0")
+                taskId = rawTaskId.trim();
+        }
+        else {
+            throw new RemoteProtocolError();
+        }
+    }
+    const rawResultIds = source.result_ids;
+    if (rawResultIds !== undefined && !Array.isArray(rawResultIds)) {
+        throw new RemoteProtocolError();
+    }
+    const resultIds = Array.isArray(rawResultIds)
+        ? rawResultIds.filter((item) => nonblank(item) !== undefined)
+        : [];
+    return {
+        ...(taskId === undefined ? {} : { task_id: taskId }),
+        ...(rawResultIds === undefined ? {} : { result_ids: resultIds })
+    };
+}
+function taskRows(response) {
+    if (Array.isArray(response))
+        return response;
+    const data = record(response)?.data;
+    if (Array.isArray(data))
+        return data;
+    throw new RemoteProtocolError();
+}
+function operationTask(response, taskId) {
+    const matches = taskRows(response).flatMap((candidate) => {
+        const item = record(candidate);
+        return nonblank(item?.id) === taskId ? [item] : [];
+    });
+    if (matches.length === 0)
+        return null;
+    if (matches.length !== 1)
+        throw new RemoteProtocolError();
+    const item = matches[0];
+    const status = item.status;
+    const progress = item.progress;
+    const totalCount = item.total_count;
+    const successCount = item.success_count;
+    const failCount = item.fail_count;
+    if (!Number.isInteger(status)
+        || typeof progress !== "number" || !Number.isFinite(progress) || progress < 0
+        || (totalCount !== null
+            && (!Number.isInteger(totalCount) || totalCount < 0))
+        || (successCount !== null
+            && (!Number.isInteger(successCount) || successCount < 0))
+        || (failCount !== null
+            && (!Number.isInteger(failCount) || failCount < 0))) {
+        throw new RemoteProtocolError();
+    }
+    return {
+        id: taskId,
+        status: status,
+        progress,
+        total_count: totalCount,
+        success_count: successCount,
+        fail_count: failCount
+    };
+}
+function operationChildren(response) {
+    const root = record(response);
+    const source = record(root?.data) ?? root;
+    if (source === undefined)
+        throw new RemoteProtocolError();
+    const rawResultIds = source.result_ids;
+    if (rawResultIds !== undefined && !Array.isArray(rawResultIds)) {
+        throw new RemoteProtocolError();
+    }
+    const repositoryId = nonblank(source.repository_id);
+    const targetRepositoryId = nonblank(source.target_repository_id);
+    const targetParentId = nonblank(source.target_parent_id);
+    return {
+        result_ids: Array.isArray(rawResultIds)
+            ? rawResultIds.filter((item) => nonblank(item) !== undefined)
+            : [],
+        ...(repositoryId === undefined ? {} : { repository_id: repositoryId }),
+        ...(targetRepositoryId === undefined ? {} : {
+            target_repository_id: targetRepositoryId
+        }),
+        ...(targetParentId === undefined ? {} : { target_parent_id: targetParentId })
+    };
+}
+function assertSingleOperationInput(input) {
+    if (nonblank(input.entryId) === undefined
+        || (input.kind !== "asset" && input.kind !== "folder")
+        || (input.operation !== "move" && input.operation !== "copy")
+        || nonblank(input.sourceRepositoryId) === undefined
+        || nonblank(input.targetRepositoryId) === undefined
+        || nonblank(input.targetFolderId) === undefined) {
+        throw new TypeError("Invalid DAM single-entry operation input.");
+    }
+}
+function assetId(response) {
+    const root = record(response);
+    const nested = record(root?.data);
+    const id = nonblank(root?.id) ?? nonblank(nested?.id);
+    if (id === undefined)
+        throw new RemoteRequestError();
+    return id;
+}
+function responseRecords(response) {
+    const root = record(response);
+    const nested = record(root?.data);
+    return [root, nested].filter((item) => item !== undefined);
+}
+function searchItems(response) {
+    if (Array.isArray(response))
+        return response;
+    for (const source of responseRecords(response)) {
+        for (const key of ["data", "list", "items"]) {
+            if (Array.isArray(source[key]))
+                return source[key];
+        }
+    }
+    return undefined;
+}
+function firstValue(response, keys) {
+    for (const source of responseRecords(response).reverse()) {
+        for (const key of keys) {
+            if (source[key] !== undefined)
+                return source[key];
+        }
+    }
+    return undefined;
+}
+function searchResult(response, input) {
+    const items = searchItems(response);
+    if (items === undefined)
+        throw new RemoteRequestError();
+    const assets = items.flatMap((item) => {
+        const asset = projectDamAssetSummary(item);
+        return asset === undefined ? [] : [asset];
+    });
+    const suppliedTotal = finiteNumber(firstValue(response, ["total", "count"]));
+    const total = suppliedTotal === undefined || suppliedTotal < 0 ? items.length : suppliedTotal;
+    const suppliedFinish = firstValue(response, ["finish"]);
+    const finish = typeof suppliedFinish === "boolean"
+        ? suppliedFinish
+        : items.length >= total;
+    const cursor = nonblank(firstValue(response, ["query_id", "cursor"]));
+    return {
+        repository_ids: input.repositoryIds,
+        page_size: input.pageSize,
+        total,
+        finish,
+        ...(!finish && cursor !== undefined ? { next_cursor: cursor } : {}),
+        assets
+    };
+}
+function requestContext(input) {
+    return {
+        credential: input.access.credential,
+        organizationId: input.access.organizationId,
+        signal: input.signal
+    };
+}
+function recycleBody(input) {
+    return {
+        repository_id: input.repositoryId,
+        file_ids: [input.assetId],
+        folder_ids: []
+    };
+}
+export function createDamApiAdapter(dependencies) {
+    return {
+        async search(input) {
+            const response = await dependencies.transport.postJson({
+                path: "/dam/asset/v2/search/simple",
+                body: {
+                    keyword: input.keyword,
+                    repository_ids: input.repositoryIds,
+                    folder_ids: input.folderId === undefined ? [] : [input.folderId],
+                    include_child_folder: input.includeChildFolder,
+                    recycle: false,
+                    page_size: input.pageSize,
+                    sort: ["-top_time", "-updated_at"],
+                    ...(input.cursor === undefined
+                        ? {}
+                        : { query_id: input.cursor }),
+                    ...(input.type === undefined
+                        ? {}
+                        : { content_format_list: contentFormats[input.type] }),
+                    ...(input.assetFormats === undefined || input.assetFormats.length === 0
+                        ? {}
+                        : { format: input.assetFormats }),
+                    ...(input.tagIds === undefined || input.tagIds.length === 0
+                        ? {}
+                        : { tag_ids: input.tagIds })
+                },
+                ...requestContext(input)
+            });
+            return searchResult(response, input);
+        },
+        async listFolders(input) {
+            const response = await dependencies.transport.getJsonResponse({
+                path: "/tb-dam/folders",
+                query: {
+                    repository_ids: input.repositoryId,
+                    parent_id: input.parentId,
+                    keyword: input.query ?? "",
+                    page_num: String(input.page),
+                    page_size: String(input.pageSize),
+                    filter_no_permission: "true",
+                    include_children: String(input.query !== undefined),
+                    sort: "topTime:desc,updatedAt:desc"
+                },
+                ...requestContext(input)
+            });
+            const pagination = folderPagination(response.headers);
+            return {
+                repository_id: input.repositoryId,
+                parent_id: input.parentId,
+                page: pagination.page,
+                page_size: pagination.pageSize,
+                total: pagination.total,
+                folders: folderRows(response.body)
+            };
+        },
+        async listTags(input) {
+            const response = await dependencies.transport.getJson({
+                path: "/tb-dam/tags",
+                query: {
+                    repository_id: input.repositoryId,
+                    group_id: "",
+                    ...(input.query === undefined ? {} : { keyword: input.query })
+                },
+                ...requestContext(input)
+            });
+            return { repository_id: input.repositoryId, tags: tagRows(response) };
+        },
+        async getDownloadUrls(input) {
+            const response = await dependencies.transport.getJson({
+                path: `/dam/asset/files/download/${encodeURIComponent(input.assetId)}/url-list`,
+                query: { repository_id: input.repositoryId },
+                ...requestContext(input)
+            });
+            return downloadUrls(response);
+        },
+        async getFolder(input) {
+            let response;
+            try {
+                response = await dependencies.transport.getJson({
+                    path: `/dam/folders/${encodeURIComponent(input.folderId)}`,
+                    query: { repository_id: input.repositoryId },
+                    ...requestContext(input)
+                });
+            }
+            catch (error) {
+                if (error instanceof RemoteRequestError && error.status === 404) {
+                    throw new DamFolderNotFoundError();
+                }
+                throw error;
+            }
+            return folderDetail(response);
+        },
+        async renameEntry(input) {
+            await dependencies.transport.putJson({
+                path: input.kind === "asset"
+                    ? `/dam/asset/${encodeURIComponent(input.entryId)}/rename`
+                    : `/dam/folders/${encodeURIComponent(input.entryId)}/rename`,
+                body: {
+                    id: input.entryId,
+                    repository_id: input.repositoryId,
+                    title: input.title
+                },
+                ...requestContext(input)
+            });
+        },
+        async submitEntryOperation(input) {
+            assertSingleOperationInput(input);
+            const asset = input.kind === "asset";
+            const body = asset
+                ? {
+                    source_infos: [{
+                            source_repository_id: input.sourceRepositoryId,
+                            content_ids: [input.entryId]
+                        }],
+                    target_folder_id: input.targetFolderId,
+                    target_repository_id: input.targetRepositoryId,
+                    ...(input.operation === "copy" ? { expand: false } : {})
+                }
+                : {
+                    folder_ids: [input.entryId],
+                    parent_id: input.targetFolderId,
+                    repository_id: input.sourceRepositoryId,
+                    target_repository_id: input.targetRepositoryId,
+                    ...(input.operation === "copy" ? { expand: false } : {})
+                };
+            const response = await dependencies.transport.postJson({
+                path: asset
+                    ? `/dam/asset/multi-repository/${input.operation}`
+                    : `/dam/folders/v2/${input.operation}`,
+                body,
+                ...requestContext(input)
+            });
+            return operationSubmission(response);
+        },
+        async getOperationTask(input) {
+            const response = await dependencies.transport.getJson({
+                path: "/dam/task/list",
+                query: { ids: input.taskId },
+                ...requestContext(input)
+            });
+            return operationTask(response, input.taskId);
+        },
+        async getOperationChildren(input) {
+            const response = await dependencies.transport.getJson({
+                path: `/dam/task/children-detail/${encodeURIComponent(input.taskId)}`,
+                ...requestContext(input)
+            });
+            return operationChildren(response);
+        },
+        async getAsset(input) {
+            let response;
+            try {
+                response = await dependencies.transport.getJson({
+                    path: `/dam/asset/${encodeURIComponent(input.assetId)}`,
+                    ...requestContext(input)
+                });
+            }
+            catch (error) {
+                if (error instanceof RemoteRequestError && error.status === 404) {
+                    throw new DamAssetNotFoundError();
+                }
+                throw error;
+            }
+            const asset = projectDamAssetDetail(response, input.assetId);
+            if (asset === undefined)
+                throw new RemoteRequestError();
+            return asset;
+        },
+        async createAssetId(input) {
+            const response = await dependencies.transport.postJson({
+                path: "/tb-dam/asset/id",
+                body: {},
+                ...requestContext(input)
+            });
+            return assetId(response);
+        },
+        async createMaterial(input) {
+            const response = await dependencies.transport.postJson({
+                path: "/dam/asset/createMaterial",
+                body: input.body,
+                ...requestContext(input)
+            });
+            const asset = projectDamAssetDetail(response, input.fallback);
+            if (asset === undefined)
+                throw new RemoteRequestError();
+            return asset;
+        },
+        async getBatchStatus(input) {
+            const response = await dependencies.transport.getJson({
+                path: "/dam/asset/batch-status",
+                query: { ids: input.assetId },
+                ...requestContext(input)
+            });
+            return projectDamAssetDetail(response, input.fallback) ?? null;
+        },
+        async recycle(input) {
+            await dependencies.transport.postJson({
+                path: "/dam/recycle-bin",
+                body: recycleBody(input),
+                ...requestContext(input)
+            });
+        },
+        async deleteRecycled(input) {
+            await dependencies.transport.postJson({
+                path: "/dam/recycle-bin/delete",
+                body: recycleBody(input),
+                ...requestContext(input)
+            });
+        }
+    };
+}