gaoding-cli 1.0.0-alpha.10

package/dist/src/features/dam/asset-projection.js

@@ -0,0 +1,270 @@
+import { isSensitiveKey } from "../../platform/redact.js";
+import { parseSafeRemoteAssetUrl } from "../../platform/url-safety.js";
+const publicAssetTypes = new Set([
+    "image",
+    "video",
+    "audio",
+    "font",
+    "template",
+    "file"
+]);
+const recognizableAssetKeys = new Set([
+    "asset_id",
+    "id",
+    "content_id",
+    "title",
+    "name",
+    "description",
+    "format",
+    "type",
+    "content_format",
+    "storage_format",
+    "origin_info",
+    "originInfo",
+    "origin_url",
+    "url",
+    "preview",
+    "preview_info",
+    "previewInfo",
+    "cover",
+    "cover_url",
+    "analysis_result",
+    "analysis_status"
+]);
+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 findAssetRecord(value) {
+    const queue = [value];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const candidate = queue.shift();
+        if (Array.isArray(candidate)) {
+            queue.push(...candidate);
+            continue;
+        }
+        const item = record(candidate);
+        if (item === undefined || seen.has(item))
+            continue;
+        seen.add(item);
+        if (Object.keys(item).some((key) => recognizableAssetKeys.has(key)))
+            return item;
+        for (const key of ["data", "asset", "asset_info", "item", "result"]) {
+            if (item[key] !== undefined)
+                queue.push(item[key]);
+        }
+    }
+    return undefined;
+}
+function safePublicUrl(value) {
+    const raw = nonblank(value);
+    if (raw === undefined)
+        return undefined;
+    try {
+        const url = parseSafeRemoteAssetUrl(raw);
+        for (const key of [...url.searchParams.keys()]) {
+            if (isSensitiveKey(key))
+                url.searchParams.delete(key);
+        }
+        return url.href;
+    }
+    catch {
+        return undefined;
+    }
+}
+function timestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const milliseconds = Math.abs(value) < 1_000_000_000_000 ? value * 1000 : value;
+        const date = new Date(milliseconds);
+        return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+    }
+    const text = nonblank(value);
+    if (text === undefined)
+        return undefined;
+    const date = new Date(text);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function tags(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const result = value
+        .map((item) => typeof item === "string" ? nonblank(item) : nonblank(record(item)?.name))
+        .filter((item) => item !== undefined);
+    return result.length === 0 ? undefined : result;
+}
+function tagIds(tagIdsValue, tagsValue) {
+    const candidates = Array.isArray(tagIdsValue)
+        ? tagIdsValue
+        : Array.isArray(tagsValue)
+            ? tagsValue.map((item) => record(item)?.id)
+            : [];
+    const result = candidates.filter((item) => (typeof item === "string" && item.trim() !== "")
+        || (typeof item === "number" && Number.isFinite(item)));
+    return result.length === 0 ? undefined : result;
+}
+function assetType(item, format, mediaType) {
+    const explicit = nonblank(item.type)?.toLowerCase();
+    if (explicit !== undefined && publicAssetTypes.has(explicit))
+        return explicit;
+    const contentFormat = (nonblank(item.content_format) ?? nonblank(item.storage_format))?.toLowerCase();
+    if (contentFormat === "gdpic" || contentFormat === "gdimage")
+        return "image";
+    if (contentFormat === "gdvideo")
+        return "video";
+    if (contentFormat === "gdaudio")
+        return "audio";
+    if (contentFormat === "gdfont")
+        return "font";
+    if (contentFormat === "gdtemplate")
+        return "template";
+    if (contentFormat === "gdfile" || contentFormat === "gdslide")
+        return "file";
+    const mediaCategory = mediaType?.split("/", 1)[0]?.toLowerCase();
+    if (mediaCategory !== undefined && publicAssetTypes.has(mediaCategory))
+        return mediaCategory;
+    const normalizedFormat = format?.toLowerCase();
+    if (normalizedFormat !== undefined
+        && ["png", "jpg", "jpeg", "gif", "webp", "svg", "avif", "heic"].includes(normalizedFormat)) {
+        return "image";
+    }
+    if (normalizedFormat !== undefined
+        && ["mp4", "mov", "webm", "mkv"].includes(normalizedFormat))
+        return "video";
+    if (normalizedFormat !== undefined
+        && ["mp3", "wav", "m4a", "aac", "ogg", "flac"].includes(normalizedFormat)) {
+        return "audio";
+    }
+    return undefined;
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function normalizeAsset(value, fallback) {
+    const item = findAssetRecord(value);
+    if (item === undefined)
+        return undefined;
+    const fallbackAsset = typeof fallback === "object" ? fallback : undefined;
+    const origin = record(item.origin_info) ?? record(item.originInfo);
+    const design = record(item.design_info) ?? record(item.designInfo);
+    const preview = record(item.preview)
+        ?? record(item.preview_info)
+        ?? record(item.previewInfo)
+        ?? record(item.cover);
+    const repository = record(item.repository_info) ?? record(item.repositoryInfo);
+    const folder = record(item.folder_info) ?? record(item.folderInfo);
+    const format = nonblank(origin?.format) ?? nonblank(item.format);
+    const mediaType = nonblank(origin?.mime_type)
+        ?? nonblank(item.mime_type)
+        ?? nonblank(item.mimeType);
+    const assetId = nonblank(item.asset_id)
+        ?? nonblank(item.id)
+        ?? nonblank(item.content_id)
+        ?? (typeof fallback === "string" ? fallback : fallbackAsset?.asset_id);
+    if (assetId === undefined)
+        return undefined;
+    return compact({
+        ...fallbackAsset,
+        asset_id: assetId,
+        title: nonblank(item.title) ?? nonblank(item.name) ?? fallbackAsset?.title,
+        description: nonblank(item.description) ?? fallbackAsset?.description,
+        format: format ?? fallbackAsset?.format,
+        type: assetType(item, format, mediaType) ?? fallbackAsset?.type,
+        size: finiteNumber(origin?.size) ?? finiteNumber(item.size) ?? fallbackAsset?.size,
+        url: safePublicUrl(origin?.url ?? item.origin_url ?? item.url) ?? fallbackAsset?.url,
+        cover_url: safePublicUrl(preview?.url ?? item.cover_url ?? item.preview_url) ?? fallbackAsset?.cover_url,
+        width: finiteNumber(design?.width)
+            ?? finiteNumber(preview?.width)
+            ?? finiteNumber(item.width)
+            ?? fallbackAsset?.width,
+        height: finiteNumber(design?.height)
+            ?? finiteNumber(preview?.height)
+            ?? finiteNumber(item.height)
+            ?? fallbackAsset?.height,
+        duration: finiteNumber(design?.duration)
+            ?? finiteNumber(preview?.duration)
+            ?? finiteNumber(item.duration)
+            ?? fallbackAsset?.duration,
+        repository_id: nonblank(item.repository_id)
+            ?? nonblank(repository?.id)
+            ?? nonblank(repository?.repository_id)
+            ?? fallbackAsset?.repository_id,
+        repository_name: nonblank(item.repository_name)
+            ?? nonblank(repository?.name)
+            ?? nonblank(repository?.title)
+            ?? fallbackAsset?.repository_name,
+        folder_id: nonblank(item.folder_id)
+            ?? nonblank(folder?.id)
+            ?? fallbackAsset?.folder_id,
+        folder_name: nonblank(item.folder_name)
+            ?? nonblank(folder?.name)
+            ?? nonblank(folder?.title)
+            ?? fallbackAsset?.folder_name,
+        tags: tags(item.tags),
+        tag_ids: tagIds(item.tag_ids, item.tags) ?? fallbackAsset?.tag_ids,
+        analysis_status: finiteNumber(item.analysis_result)
+            ?? finiteNumber(item.analysis_status)
+            ?? nonblank(item.analysis_result)
+            ?? nonblank(item.analysis_status)
+            ?? fallbackAsset?.analysis_status,
+        created_at: timestamp(item.created_at) ?? fallbackAsset?.created_at,
+        updated_at: timestamp(item.updated_at) ?? fallbackAsset?.updated_at
+    });
+}
+export function projectDamAssetDetail(value, fallback) {
+    const asset = normalizeAsset(value, fallback);
+    if (asset === undefined)
+        return undefined;
+    return compact({
+        asset_id: asset.asset_id,
+        title: asset.title,
+        description: asset.description,
+        format: asset.format,
+        type: asset.type,
+        size: asset.size,
+        url: asset.url,
+        cover_url: asset.cover_url,
+        width: asset.width,
+        height: asset.height,
+        duration: asset.duration,
+        repository_id: asset.repository_id,
+        repository_name: asset.repository_name,
+        folder_id: asset.folder_id,
+        folder_name: asset.folder_name,
+        tag_ids: asset.tag_ids,
+        analysis_status: asset.analysis_status,
+        created_at: asset.created_at,
+        updated_at: asset.updated_at
+    });
+}
+export function projectDamAssetSummary(value) {
+    const asset = normalizeAsset(value);
+    if (asset === undefined)
+        return undefined;
+    return compact({
+        asset_id: asset.asset_id,
+        title: asset.title,
+        format: asset.format,
+        type: asset.type,
+        size: asset.size,
+        url: asset.url,
+        cover_url: asset.cover_url,
+        width: asset.width,
+        height: asset.height,
+        repository_id: asset.repository_id,
+        folder_id: asset.folder_id,
+        folder_name: asset.folder_name,
+        tags: asset.tags,
+        tag_ids: asset.tag_ids,
+        analysis_status: asset.analysis_status,
+        created_at: asset.created_at,
+        updated_at: asset.updated_at
+    });
+}

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

@@ -0,0 +1,206 @@
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { projectDamAssetDetail, projectDamAssetSummary } from "./asset-projection.js";
+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 repositories(response) {
+    const source = Array.isArray(response)
+        ? response
+        : Array.isArray(record(response)?.data)
+            ? record(response)?.data
+            : undefined;
+    if (source === undefined)
+        throw new RemoteRequestError();
+    return source.flatMap((value) => {
+        const item = record(value);
+        const id = nonblank(item?.repository_id) ?? nonblank(item?.id);
+        if (item === undefined || id === undefined)
+            return [];
+        const name = nonblank(item.name) ?? nonblank(item.title);
+        const type = finiteNumber(item.type);
+        return [{
+                id,
+                ...(name === undefined ? {} : { name }),
+                ...(type === undefined ? {} : { type })
+            }];
+    });
+}
+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 listRepositories(input) {
+            const response = await dependencies.transport.getJson({
+                path: "/tb-dam/repositories",
+                ...requestContext(input)
+            });
+            return repositories(response);
+        },
+        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,
+                    page_num: 1,
+                    page: 1,
+                    sort: ["-top_time", "-updated_at"],
+                    ...(input.cursor === undefined
+                        ? {}
+                        : { query_id: input.cursor, cursor: input.cursor }),
+                    ...(input.type === undefined
+                        ? {}
+                        : { content_format_list: contentFormats[input.type] }),
+                    ...(input.assetFormats === undefined || input.assetFormats.length === 0
+                        ? {}
+                        : { format_list: input.assetFormats }),
+                    ...(input.tagIds === undefined || input.tagIds.length === 0
+                        ? {}
+                        : { tag_ids: input.tagIds })
+                },
+                ...requestContext(input)
+            });
+            return searchResult(response, input);
+        },
+        async getAsset(input) {
+            const response = await dependencies.transport.getJson({
+                path: `/dam/asset/${encodeURIComponent(input.assetId)}`,
+                ...requestContext(input)
+            });
+            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)
+            });
+        }
+    };
+}

package/dist/src/features/dam/object-storage.js

@@ -0,0 +1,191 @@
+import { createHmac } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import OSS from "ali-oss";
+export class ObjectStorageUploadError extends Error {
+    constructor() {
+        super("素材上传失败。");
+        this.name = "ObjectStorageUploadError";
+    }
+}
+function normalizeEndpoint(value) {
+    try {
+        const url = new URL(value.includes("://") ? value : `https://${value}`);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            throw new Error("unsupported protocol");
+        }
+        return url;
+    }
+    catch {
+        throw new ObjectStorageUploadError();
+    }
+}
+function endpointOrigin(value) {
+    return normalizeEndpoint(value).origin;
+}
+function endpointOrder(token) {
+    return [...new Set([
+            token.endpoint,
+            token.standbyEndpoint,
+            token.accelerateEndpoint
+        ].filter((value) => value !== undefined).map(endpointOrigin))];
+}
+function errorText(error) {
+    if (!(error instanceof Error))
+        return "";
+    const code = "code" in error && typeof error.code === "string" ? error.code : "";
+    return `${code} ${error.message}`;
+}
+function isTransient(error) {
+    const text = errorText(error);
+    return text.includes("socket hang up")
+        || text.includes("ECONNRESET")
+        || text.includes("ETIMEDOUT")
+        || text.includes("EPIPE");
+}
+function isUnsupportedAuthorization(error) {
+    return errorText(error).includes("Unsupported Authorization Type");
+}
+function sleepWithSignal(milliseconds, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, milliseconds);
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+const defaultPutOss = async (input) => {
+    input.signal.throwIfAborted();
+    const client = new OSS({
+        accessKeyId: input.token.accessKeyId,
+        accessKeySecret: input.token.accessKeySecret,
+        stsToken: input.token.securityToken,
+        endpoint: input.endpoint,
+        region: input.token.region,
+        bucket: input.token.bucketName,
+        secure: true,
+        authorizationV4: input.authorizationV4
+    });
+    await client.put(input.token.objectName, input.filePath, {
+        headers: { "Content-Type": input.mediaType }
+    });
+    input.signal.throwIfAborted();
+};
+async function attemptOss(input, dependencies) {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        input.signal.throwIfAborted();
+        try {
+            await dependencies.putOss(input);
+            input.signal.throwIfAborted();
+            return "success";
+        }
+        catch (error) {
+            if (input.signal.aborted)
+                throw input.signal.reason;
+            if (!input.authorizationV4 && isUnsupportedAuthorization(error)) {
+                return "unsupported-authorization";
+            }
+            if (!isTransient(error))
+                throw new ObjectStorageUploadError();
+            if (attempt === 1)
+                return "transient-exhausted";
+            await dependencies.sleep(300, input.signal);
+        }
+    }
+    return "transient-exhausted";
+}
+function isHuaweiObs(endpoint) {
+    const hostname = normalizeEndpoint(endpoint).hostname;
+    return /(^|\.)obs\.[^.]+\.myhuaweicloud\.com$/i.test(hostname);
+}
+function encodedObjectPath(objectName) {
+    return objectName.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
+}
+async function uploadObs(input, dependencies) {
+    input.signal.throwIfAborted();
+    const file = await stat(input.filePath);
+    input.signal.throwIfAborted();
+    const endpoint = normalizeEndpoint(input.endpoint);
+    const objectName = input.token.objectName.replace(/^\/+/, "");
+    endpoint.hostname = `${input.token.bucketName}.${endpoint.hostname}`;
+    endpoint.pathname = `/${encodedObjectPath(objectName)}`;
+    const date = dependencies.now().toUTCString();
+    const stringToSign = [
+        "PUT",
+        "",
+        input.mediaType,
+        date,
+        `x-obs-security-token:${input.token.securityToken}`,
+        `/${input.token.bucketName}/${objectName}`
+    ].join("\n");
+    const signature = createHmac("sha1", input.token.accessKeySecret)
+        .update(stringToSign)
+        .digest("base64");
+    const stream = createReadStream(input.filePath);
+    try {
+        const response = await dependencies.fetch(endpoint, {
+            method: "PUT",
+            headers: {
+                Authorization: `OBS ${input.token.accessKeyId}:${signature}`,
+                Date: date,
+                "Content-Type": input.mediaType,
+                "Content-Length": String(file.size),
+                "x-obs-security-token": input.token.securityToken
+            },
+            body: stream,
+            signal: input.signal,
+            duplex: "half"
+        });
+        input.signal.throwIfAborted();
+        if (!response.ok) {
+            stream.destroy();
+            throw new ObjectStorageUploadError();
+        }
+    }
+    catch (error) {
+        stream.destroy();
+        if (input.signal.aborted)
+            throw input.signal.reason;
+        if (error instanceof ObjectStorageUploadError)
+            throw error;
+        throw new ObjectStorageUploadError();
+    }
+}
+export function createObjectStorageUploader(options = {}) {
+    const dependencies = {
+        putOss: options.putOss ?? defaultPutOss,
+        fetch: options.fetch ?? globalThis.fetch,
+        sleep: options.sleep ?? sleepWithSignal,
+        now: options.now ?? (() => new Date())
+    };
+    return {
+        async upload(input) {
+            input.signal.throwIfAborted();
+            const endpoints = endpointOrder(input.token);
+            if (endpoints.length === 0)
+                throw new ObjectStorageUploadError();
+            if (isHuaweiObs(endpoints[0])) {
+                await uploadObs({ ...input, endpoint: endpoints[0] }, dependencies);
+                return;
+            }
+            for (const endpoint of endpoints) {
+                const base = { ...input, endpoint, authorizationV4: false };
+                const v1 = await attemptOss(base, dependencies);
+                if (v1 === "success")
+                    return;
+                if (v1 !== "unsupported-authorization")
+                    continue;
+                const v4 = await attemptOss({ ...base, authorizationV4: true }, dependencies);
+                if (v4 === "success")
+                    return;
+            }
+            throw new ObjectStorageUploadError();
+        }
+    };
+}