@xuanqikai/one-click-upload/dist/uploaders/UploaderFactory.js

A CLI tool for one-click file upload to cloud storage services (OSS, TOS)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.UploaderFactory = void 0;
const types_1 = require("../types");
const OSSUploader_1 = require("./OSSUploader");
const TOSUploader_1 = require("./TOSUploader");
class UploaderFactory {
    /**
     * 创建上传器实例
     */
    static createUploader(config) {
        switch (config.type) {
            case types_1.ServiceType.OSS:
                return new OSSUploader_1.OSSUploader(config);
            case types_1.ServiceType.TOS:
                return new TOSUploader_1.TOSUploader(config);
            default:
                throw new Error(`Unsupported service type: ${config.type}`);
        }
    }
    /**
     * 获取支持的服务类型列表
     */
    static getSupportedTypes() {
        return Object.values(types_1.ServiceType);
    }
    /**
     * 检查服务类型是否支持
     */
    static isTypeSupported(type) {
        return Object.values(types_1.ServiceType).includes(type);
    }
    /**
     * 获取服务类型的显示名称
     */
    static getTypeDisplayName(type) {
        switch (type) {
            case types_1.ServiceType.OSS:
                return 'Alibaba Cloud OSS';
            case types_1.ServiceType.TOS:
                return 'ByteDance TOS (Volcano Engine)';
            default:
                return String(type).toUpperCase();
        }
    }
    /**
     * 获取服务类型的配置字段说明
     */
    static getConfigFields(type) {
        const commonFields = [
            {
                key: 'region',
                label: 'Region',
                required: true,
                type: 'string',
                description: 'Service region'
            },
            {
                key: 'accessKeyId',
                label: 'Access Key ID',
                required: true,
                type: 'string',
                description: 'Access key ID for authentication'
            },
            {
                key: 'accessKeySecret',
                label: 'Access Key Secret',
                required: true,
                type: 'password',
                description: 'Access key secret for authentication'
            },
            {
                key: 'bucket',
                label: 'Bucket Name',
                required: true,
                type: 'string',
                description: 'Storage bucket name'
            },
            {
                key: 'endpoint',
                label: 'Custom Endpoint (Optional)',
                required: false,
                type: 'string',
                description: 'Custom service endpoint URL'
            }
        ];
        switch (type) {
            case types_1.ServiceType.OSS:
                return [
                    ...commonFields.map(field => ({
                        ...field,
                        description: field.key === 'region' ? 'OSS region (e.g., oss-cn-hangzhou)' :
                            field.key === 'bucket' ? 'OSS bucket name' :
                                field.key === 'endpoint' ? 'Custom OSS endpoint (optional)' :
                                    field.description
                    }))
                ];
            case types_1.ServiceType.TOS:
                return [
                    ...commonFields.map(field => ({
                        ...field,
                        description: field.key === 'region' ? 'TOS region (e.g., cn-beijing)' :
                            field.key === 'bucket' ? 'TOS bucket name' :
                                field.key === 'endpoint' ? 'Custom TOS endpoint (optional)' :
                                    field.description
                    }))
                ];
            default:
                return commonFields;
        }
    }
    /**
     * 验证配置完整性
     */
    static validateConfig(config) {
        const errors = [];
        if (!config.name || !config.name.trim()) {
            errors.push('Service name is required');
        }
        if (!config.type) {
            errors.push('Service type is required');
        }
        else if (!this.isTypeSupported(config.type)) {
            errors.push(`Unsupported service type: ${config.type}`);
        }
        if (!config.config) {
            errors.push('Service configuration is required');
            return { valid: false, errors };
        }
        const fields = this.getConfigFields(config.type);
        const requiredFields = fields.filter(f => f.required);
        for (const field of requiredFields) {
            const value = config.config[field.key];
            if (!value || (typeof value === 'string' && !value.trim())) {
                errors.push(`${field.label} is required`);
            }
        }
        return {
            valid: errors.length === 0,
            errors
        };
    }
}
exports.UploaderFactory = UploaderFactory;
//# sourceMappingURL=UploaderFactory.js.map