@gaoding/cli 0.0.0 → 1.0.0

package/dist/src/features/dam/registered-uploader.js

@@ -0,0 +1,247 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
+import sharp from "sharp";
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { projectDamAssetDetail } from "./asset-projection.js";
+const imageFormats = new Set([
+    "png", "jpg", "jpeg", "gif", "svg", "webp", "jfif", "bmp", "tiff", "tif", "heic", "avif"
+]);
+const videoFormats = new Set([
+    "mp4", "avi", "flv", "mov", "3gp", "m3u8", "mpg", "asf", "wmv", "mkv", "ts", "webm", "mxf"
+]);
+const audioFormats = new Set(["mp3", "wav", "ogg", "flac"]);
+const fontFormats = new Set(["ttf", "otf"]);
+const designFormats = new Set(["psd", "ai", "sketch", "pdf"]);
+const slideFormats = new Set(["ppt", "pptx"]);
+function storageFormat(format) {
+    const normalized = format.toLowerCase();
+    if (imageFormats.has(normalized))
+        return "gdpic";
+    if (videoFormats.has(normalized))
+        return "gdvideo";
+    if (audioFormats.has(normalized))
+        return "gdaudio";
+    if (fontFormats.has(normalized))
+        return "gdfont";
+    if (designFormats.has(normalized))
+        return "gdimage";
+    if (slideFormats.has(normalized))
+        return "gdslide";
+    return normalized;
+}
+function publicType(format) {
+    if (format === "gdpic" || format === "gdimage")
+        return "image";
+    if (format === "gdvideo")
+        return "video";
+    if (format === "gdaudio")
+        return "audio";
+    if (format === "gdfont")
+        return "font";
+    if (format === "gdtemplate")
+        return "template";
+    return "file";
+}
+async function hashes(filePath, signal) {
+    signal.throwIfAborted();
+    const md5 = createHash("md5");
+    const sha1 = createHash("sha1");
+    const stream = createReadStream(filePath, { signal });
+    try {
+        for await (const chunk of stream) {
+            signal.throwIfAborted();
+            md5.update(chunk);
+            sha1.update(chunk);
+        }
+        signal.throwIfAborted();
+        return { md5: md5.digest("hex"), sha1: sha1.digest("hex") };
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw signal.reason;
+        throw error;
+    }
+}
+function filenameTitle(filename) {
+    const withoutExtension = filename.replace(/\.[^.]+$/u, "");
+    return withoutExtension === "" ? filename : withoutExtension;
+}
+function terminalAnalysisStatus(value) {
+    const normalized = typeof value === "string" ? Number(value) : value;
+    return normalized === 2 || normalized === 3 || normalized === 4;
+}
+async function defaultSleep(milliseconds, signal) {
+    signal.throwIfAborted();
+    try {
+        await delay(milliseconds, undefined, { signal });
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw signal.reason;
+        throw error;
+    }
+}
+export function createDamRegisteredUploader(dependencies) {
+    const now = dependencies.now ?? (() => new Date());
+    const sleep = dependencies.sleep ?? defaultSleep;
+    const imageMetadata = dependencies.imageMetadata
+        ?? (async (filePath) => {
+            const metadata = await sharp(filePath).metadata();
+            return { width: metadata.width, height: metadata.height };
+        });
+    async function localMetadata(file, signal) {
+        if (!file.mediaType.startsWith("image/"))
+            return {};
+        try {
+            const metadata = await imageMetadata(file.filePath);
+            signal.throwIfAborted();
+            return {
+                ...(typeof metadata.width === "number" && Number.isFinite(metadata.width)
+                    ? { width: metadata.width }
+                    : {}),
+                ...(typeof metadata.height === "number" && Number.isFinite(metadata.height)
+                    ? { height: metadata.height }
+                    : {})
+            };
+        }
+        catch {
+            if (signal.aborted)
+                throw signal.reason;
+            return {};
+        }
+    }
+    return {
+        async upload(input) {
+            try {
+                const stage = (name, run) => (dependencies.telemetry.stage(name, async () => {
+                    try {
+                        return await run();
+                    }
+                    catch (error) {
+                        if (input.signal.aborted)
+                            throw input.signal.reason;
+                        if (error instanceof RemoteRequestError)
+                            throw error;
+                        throw new RemoteRequestError();
+                    }
+                }));
+                input.signal.throwIfAborted();
+                const prepared = await stage("prepare", async () => {
+                    const [digest, metadata] = await Promise.all([
+                        hashes(input.file.filePath, input.signal),
+                        localMetadata(input.file, input.signal)
+                    ]);
+                    input.signal.throwIfAborted();
+                    const contentId = await dependencies.api.createAssetId({
+                        access: input.access,
+                        signal: input.signal
+                    });
+                    const format = input.file.format.toLowerCase();
+                    return {
+                        digest,
+                        metadata,
+                        contentId,
+                        format,
+                        damFormat: storageFormat(format),
+                        title: input.input.title ?? filenameTitle(input.file.filename),
+                        folderId: input.input.folderId ?? "0"
+                    };
+                });
+                const { digest, metadata, contentId, format, damFormat, title, folderId } = prepared;
+                const stored = await stage("upload", () => dependencies.storage.upload({
+                    file: input.file,
+                    contentId
+                }, input.access, input.signal));
+                const preview = input.file.mediaType.startsWith("image/")
+                    ? {
+                        url: stored.url,
+                        ...metadata,
+                        format
+                    }
+                    : {};
+                const body = {
+                    folder_id: folderId,
+                    repository_id: input.repository.id,
+                    second_transmission: false,
+                    storage_format: damFormat,
+                    category_ids: [],
+                    asset_info: {
+                        id: contentId,
+                        origin_url: stored.url,
+                        size: input.file.size,
+                        title,
+                        md5: digest.md5,
+                        sha1: digest.sha1,
+                        mime_type: input.file.mediaType,
+                        format,
+                        preview
+                    },
+                    ...(input.input.tagIds === undefined
+                        ? {}
+                        : { tag_ids: [...input.input.tagIds] })
+                };
+                const fallback = projectDamAssetDetail({
+                    id: contentId,
+                    title,
+                    format,
+                    type: publicType(damFormat),
+                    origin_info: {
+                        url: stored.url,
+                        size: input.file.size,
+                        format
+                    },
+                    preview_info: preview,
+                    repository_info: {
+                        id: input.repository.id,
+                        ...(input.repository.name === undefined ? {} : { name: input.repository.name })
+                    },
+                    folder_info: { id: folderId },
+                    ...(input.input.tagIds === undefined
+                        ? {}
+                        : { tag_ids: [...input.input.tagIds] })
+                });
+                if (fallback === undefined)
+                    throw new RemoteRequestError();
+                let latest = await stage("persist", () => dependencies.api.createMaterial({
+                    body,
+                    fallback,
+                    access: input.access,
+                    signal: input.signal
+                }));
+                if (input.input.waitAnalysis !== true || terminalAnalysisStatus(latest.analysis_status)) {
+                    return latest;
+                }
+                return stage("wait", async () => {
+                    const deadline = now().getTime() + 180_000;
+                    while (true) {
+                        input.signal.throwIfAborted();
+                        const current = await dependencies.api.getBatchStatus({
+                            assetId: latest.asset_id,
+                            fallback: latest,
+                            access: input.access,
+                            signal: input.signal
+                        });
+                        if (current !== null)
+                            latest = current;
+                        if (terminalAnalysisStatus(latest.analysis_status))
+                            return latest;
+                        const remaining = deadline - now().getTime();
+                        if (remaining <= 0) {
+                            dependencies.warn("素材分析仍在处理中，已返回当前结果。");
+                            return latest;
+                        }
+                        await sleep(Math.min(3000, remaining), input.signal);
+                    }
+                });
+            }
+            catch (error) {
+                if (input.signal.aborted)
+                    throw input.signal.reason;
+                if (error instanceof RemoteRequestError)
+                    throw error;
+                throw new RemoteRequestError();
+            }
+        }
+    };
+}

package/dist/src/features/dam/repository-catalog.js

@@ -0,0 +1,127 @@
+import { RemoteProtocolError } from "../../platform/remote-protocol.js";
+const permissions = new Set([
+    "OWNER",
+    "MANAGE",
+    "EDIT",
+    "USE",
+    "READ"
+]);
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function rows(value) {
+    if (Array.isArray(value))
+        return value;
+    const nested = record(value)?.data;
+    if (Array.isArray(nested))
+        return nested;
+    throw new RemoteProtocolError();
+}
+function nonblank(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function permission(value) {
+    return typeof value === "string"
+        && permissions.has(value)
+        ? value
+        : undefined;
+}
+function privateRepositories(value) {
+    return rows(value).flatMap((candidate) => {
+        const item = record(candidate);
+        const repositoryId = nonblank(item?.repository_id);
+        const name = nonblank(item?.name) ?? nonblank(item?.title);
+        const type = item?.type === 1
+            ? "personal"
+            : item?.type === 6
+                ? "draft"
+                : undefined;
+        if (repositoryId === undefined || name === undefined || type === undefined)
+            return [];
+        return [{ repository_id: repositoryId, name, type, is_default: false }];
+    });
+}
+function teamRepositories(value) {
+    return rows(value).flatMap((candidate) => {
+        const item = record(candidate);
+        const repositoryId = nonblank(item?.repository_id);
+        const name = nonblank(item?.name) ?? nonblank(item?.title);
+        if (repositoryId === undefined || name === undefined)
+            return [];
+        const permissionCode = permission(item?.permission_code);
+        return [{
+                repository_id: repositoryId,
+                name,
+                type: "team",
+                ...(permissionCode === undefined ? {} : { permission_code: permissionCode }),
+                is_default: false
+            }];
+    });
+}
+function enterpriseRepositories(value) {
+    return rows(value).flatMap((candidate) => {
+        const item = record(candidate);
+        const repositoryId = nonblank(item?.id);
+        const name = nonblank(item?.name) ?? nonblank(item?.title);
+        if (repositoryId === undefined || name === undefined)
+            return [];
+        const permissionCode = permission(item?.permission_code);
+        return [{
+                repository_id: repositoryId,
+                name,
+                type: "enterprise",
+                ...(permissionCode === undefined ? {} : { permission_code: permissionCode }),
+                is_default: false
+            }];
+    });
+}
+export function normalizeRepositoryCatalog(privateRows, teamRows, enterpriseRows) {
+    const merged = [
+        ...privateRepositories(privateRows),
+        ...teamRepositories(teamRows),
+        ...enterpriseRepositories(enterpriseRows)
+    ];
+    const seen = new Set();
+    const unique = merged.filter((repository) => {
+        if (seen.has(repository.repository_id))
+            return false;
+        seen.add(repository.repository_id);
+        return true;
+    });
+    const defaultIndex = unique.findIndex((repository) => repository.type === "personal");
+    const selectedIndex = defaultIndex === -1 && unique.length > 0 ? 0 : defaultIndex;
+    return unique.map((repository, index) => ({
+        ...repository,
+        is_default: index === selectedIndex
+    }));
+}
+function requestContext(input) {
+    return {
+        credential: input.access.credential,
+        organizationId: input.access.organizationId,
+        signal: input.signal
+    };
+}
+export function createDamRepositoryCatalog(dependencies) {
+    return {
+        async list(input) {
+            const [privateRows, teamRows, enterpriseRows] = await Promise.all([
+                dependencies.transport.getJson({
+                    path: "/tb-dam/repositories",
+                    ...requestContext(input)
+                }),
+                dependencies.transport.getJson({
+                    path: "/tb-dam/teams",
+                    ...requestContext(input)
+                }),
+                dependencies.transport.getJson({
+                    path: "/dam/org-repositories",
+                    ...requestContext(input)
+                })
+            ]);
+            return normalizeRepositoryCatalog(privateRows, teamRows, enterpriseRows);
+        }
+    };
+}

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

@@ -0,0 +1,141 @@
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { inspectUploadFile } from "../../platform/safe-upload-file.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requiredString(record, key) {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim() === "")
+        throw new RemoteRequestError();
+    return value;
+}
+function optionalString(record, key) {
+    const value = record[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim() === "")
+        throw new RemoteRequestError();
+    return value;
+}
+function parseToken(response) {
+    if (!isRecord(response))
+        throw new RemoteRequestError();
+    const record = "data" in response ? response.data : response;
+    if (!isRecord(record))
+        throw new RemoteRequestError();
+    const standbyEndpoint = optionalString(record, "standby_endpoint");
+    const accelerateEndpoint = optionalString(record, "accelerate_endpoint");
+    const authKey = optionalString(record, "auth_key");
+    return {
+        securityToken: requiredString(record, "security_token"),
+        accessKeyId: requiredString(record, "access_key_id"),
+        accessKeySecret: requiredString(record, "access_key_secret"),
+        endpoint: requiredString(record, "endpoint"),
+        ...(standbyEndpoint === undefined ? {} : { standbyEndpoint }),
+        ...(accelerateEndpoint === undefined ? {} : { accelerateEndpoint }),
+        region: requiredString(record, "region"),
+        bucketName: requiredString(record, "bucket_name"),
+        objectName: requiredString(record, "object_name"),
+        host: requiredString(record, "host"),
+        ...(authKey === undefined ? {} : { authKey })
+    };
+}
+function publicAssetUrl(token) {
+    try {
+        const normalizedHost = token.host.includes("://") ? token.host : `https://${token.host}`;
+        const url = new URL(normalizedHost);
+        if ((url.protocol !== "http:" && url.protocol !== "https:")
+            || url.username !== ""
+            || url.password !== "") {
+            throw new RemoteRequestError();
+        }
+        url.search = "";
+        url.hash = "";
+        if (!url.pathname.endsWith("/"))
+            url.pathname += "/";
+        url.pathname += token.objectName
+            .replace(/^\/+/, "")
+            .split("/")
+            .map(encodeURIComponent)
+            .join("/");
+        if (token.authKey !== undefined)
+            url.searchParams.set("auth_key", token.authKey);
+        return url.href;
+    }
+    catch (error) {
+        if (error instanceof RemoteRequestError)
+            throw error;
+        throw new RemoteRequestError();
+    }
+}
+function storageToken(token) {
+    return {
+        securityToken: token.securityToken,
+        accessKeyId: token.accessKeyId,
+        accessKeySecret: token.accessKeySecret,
+        endpoint: token.endpoint,
+        ...(token.standbyEndpoint === undefined
+            ? {}
+            : { standbyEndpoint: token.standbyEndpoint }),
+        ...(token.accelerateEndpoint === undefined
+            ? {}
+            : { accelerateEndpoint: token.accelerateEndpoint }),
+        region: token.region,
+        bucketName: token.bucketName,
+        objectName: token.objectName
+    };
+}
+export function createDamStorageUploader(dependencies) {
+    return {
+        inspect(input, signal) {
+            return inspectUploadFile({ ...input, signal });
+        },
+        async upload(input, access, signal) {
+            signal.throwIfAborted();
+            let token;
+            let url;
+            try {
+                const response = await dependencies.transport.postJson({
+                    path: "/tb-dam/asset/upload/tokens",
+                    body: {
+                        ...(input.contentId === undefined ? {} : { content_id: input.contentId }),
+                        format: input.file.format
+                    },
+                    credential: access.credential,
+                    organizationId: access.organizationId,
+                    signal
+                });
+                signal.throwIfAborted();
+                token = parseToken(response);
+                url = publicAssetUrl(token);
+            }
+            catch (error) {
+                if (signal.aborted)
+                    throw signal.reason;
+                if (error instanceof RemoteRequestError)
+                    throw error;
+                throw new RemoteRequestError();
+            }
+            try {
+                await dependencies.storage.upload({
+                    token: storageToken(token),
+                    filePath: input.file.filePath,
+                    mediaType: input.file.mediaType,
+                    signal
+                });
+                signal.throwIfAborted();
+                return {
+                    ...input.file,
+                    url
+                };
+            }
+            catch (error) {
+                if (signal.aborted)
+                    throw signal.reason;
+                if (error instanceof RemoteRequestError)
+                    throw error;
+                throw new RemoteRequestError();
+            }
+        }
+    };
+}

package/dist/src/features/dam/transient-uploader.js

@@ -0,0 +1,17 @@
+export function createDamTransientUploader(dependencies) {
+    return {
+        async upload(input, access, signal) {
+            const file = await dependencies.storageUpload.inspect({
+                url: input.url,
+                ...(input.mediaType === undefined ? {} : { claimedMediaType: input.mediaType })
+            }, signal);
+            const stored = await dependencies.storageUpload.upload({ file }, access, signal);
+            return {
+                url: stored.url,
+                mediaType: stored.mediaType,
+                filename: input.filename ?? stored.filename,
+                fromUserUpload: true
+            };
+        }
+    };
+}