@dinoxx/dinox-cli 1.0.18 → 1.0.19

package/dist/commands/storage/repo.js

@@ -0,0 +1,751 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { DeleteObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import sharp from 'sharp';
+import { generateId } from '../../utils/id.js';
+import { DinoxError } from '../../utils/errors.js';
+const ACTIVE_CUSTOM_STORAGE_CONFIG_ID_KEY = 'storage:active_custom_config_id';
+const DEFAULT_STORAGE_PROTOCOL = 's3';
+const DEFAULT_STORAGE_PATH_PREFIX = 'dinox_note/';
+const DEFAULT_CONTENT_TYPE = 'application/octet-stream';
+const OFFICIAL_STORAGE_PROVIDER = 'aliyun-official';
+const OFFICIAL_STORAGE_PROVIDER_NAME = '官方云';
+const UPLOAD_CATEGORY_VALUES = ['images', 'audios', 'files', 'videos'];
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeTextArray(raw) {
+    const input = normalizeText(raw);
+    if (!input) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(input);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed
+            .map((entry) => normalizeText(String(entry)))
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeBool(value) {
+    return Number(value ?? 0) === 1;
+}
+function normalizeNumber(value) {
+    const numeric = typeof value === 'number' ? value : Number(value ?? 0);
+    return Number.isFinite(numeric) ? numeric : 0;
+}
+function normalizeStoragePathPrefix(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return DEFAULT_STORAGE_PATH_PREFIX;
+    }
+    return trimmed.endsWith('/') ? trimmed : `${trimmed}/`;
+}
+function finishStorageHost(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new DinoxError('Storage endpoint is required.');
+    }
+    const candidate = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+    try {
+        const parsed = new URL(candidate);
+        parsed.pathname = '';
+        parsed.search = '';
+        parsed.hash = '';
+        return parsed.toString().replace(/\/$/, '');
+    }
+    catch (error) {
+        throw new DinoxError(`Invalid storage endpoint: ${trimmed}`, { cause: error });
+    }
+}
+function buildVirtualHostedStyleUrl(bucket, endpoint, key) {
+    const parsed = new URL(endpoint);
+    const protocol = parsed.protocol || 'https:';
+    const port = parsed.port ? `:${parsed.port}` : '';
+    const host = parsed.hostname || parsed.host;
+    const hostWithBucket = host.startsWith(`${bucket}.`) ? host : `${bucket}.${host}`;
+    return {
+        finalUrl: `${protocol}//${hostWithBucket}${port}/${key}`,
+        domain: `${protocol}//${hostWithBucket}${port}`,
+    };
+}
+function buildPathStyleUrl(bucket, endpoint, key) {
+    const parsed = new URL(endpoint);
+    const protocol = parsed.protocol || 'https:';
+    const port = parsed.port ? `:${parsed.port}` : '';
+    const host = parsed.hostname || parsed.host;
+    return {
+        finalUrl: `${protocol}//${host}${port}/${bucket}/${key}`,
+        domain: `${protocol}//${host}${port}`,
+    };
+}
+function getFileExtension(filePath) {
+    const extension = path.extname(filePath).trim().replace(/^\./, '');
+    return extension.toLowerCase();
+}
+function guessContentType(filePath) {
+    const extension = getFileExtension(filePath);
+    switch (extension) {
+        case 'jpg':
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'png':
+            return 'image/png';
+        case 'gif':
+            return 'image/gif';
+        case 'webp':
+            return 'image/webp';
+        case 'svg':
+            return 'image/svg+xml';
+        case 'mp3':
+            return 'audio/mpeg';
+        case 'm4a':
+            return 'audio/mp4';
+        case 'wav':
+            return 'audio/wav';
+        case 'ogg':
+        case 'opus':
+            return 'audio/ogg';
+        case 'mp4':
+            return 'video/mp4';
+        case 'mov':
+            return 'video/quicktime';
+        case 'webm':
+            return 'video/webm';
+        case 'pdf':
+            return 'application/pdf';
+        case 'json':
+            return 'application/json';
+        case 'md':
+            return 'text/markdown';
+        case 'txt':
+            return 'text/plain';
+        case 'csv':
+            return 'text/csv';
+        default:
+            return DEFAULT_CONTENT_TYPE;
+    }
+}
+function buildObjectId(userId, category, filePath) {
+    const ext = getFileExtension(filePath);
+    const suffix = ext ? `.${ext}` : '';
+    return `assets/${userId}/${category}/${generateId()}${suffix}`;
+}
+function generateThumbnailKey(originalKey) {
+    const lastSlashIndex = originalKey.lastIndexOf('/');
+    if (lastSlashIndex === -1) {
+        const filenameWithoutExt = originalKey.replace(/\.[^.]+$/, '');
+        return `thumb/${filenameWithoutExt}_thumbnail.webp`;
+    }
+    const dirPath = originalKey.slice(0, lastSlashIndex);
+    const filename = originalKey.slice(lastSlashIndex + 1);
+    const filenameWithoutExt = filename.replace(/\.[^.]+$/, '');
+    return `${dirPath}/thumb/${filenameWithoutExt}_thumbnail.webp`;
+}
+function buildStorageTarget(config, key) {
+    const resolvedEndpoint = finishStorageHost(config.endpoint);
+    if (config.customDomain) {
+        const domain = finishStorageHost(config.customDomain);
+        return {
+            storageUrl: `${domain}/${key}`,
+            domain,
+        };
+    }
+    const target = config.forcePathStyle
+        ? buildPathStyleUrl(config.bucket, resolvedEndpoint, key)
+        : buildVirtualHostedStyleUrl(config.bucket, resolvedEndpoint, key);
+    return {
+        storageUrl: target.finalUrl,
+        domain: target.domain,
+    };
+}
+function isOfficialStorageProvider(provider) {
+    return provider === OFFICIAL_STORAGE_PROVIDER;
+}
+function getStorageProviderName(provider) {
+    if (isOfficialStorageProvider(provider)) {
+        return OFFICIAL_STORAGE_PROVIDER_NAME;
+    }
+    switch (provider) {
+        case 'bitiful':
+            return '缤纷云';
+        case 'tencent':
+            return '腾讯云';
+        case 'aliyun':
+            return '阿里云';
+        case 'aws':
+            return 'AWS';
+        case 'qiniu':
+            return '七牛云';
+        case 'cloudflare':
+            return 'Cloudflare';
+        default:
+            return provider;
+    }
+}
+function toSanitizedStorage(config, isActive) {
+    return {
+        id: config.id,
+        aliasName: config.aliasName,
+        provider: config.provider,
+        endpoint: config.endpoint,
+        bucket: config.bucket,
+        region: config.region,
+        forcePathStyle: config.forcePathStyle,
+        pathPrefix: config.pathPrefix,
+        customDomain: config.customDomain,
+        legacyDomains: config.legacyDomains,
+        isPrivate: config.isPrivate,
+        hasAccessKeyId: config.accessKeyId.length > 0,
+        hasSecretAccessKey: config.secretAccessKey.length > 0,
+        isActive,
+    };
+}
+function buildStorageUsageLabel(args) {
+    const { provider, bucket, configsByKey, configsByProvider } = args;
+    if (isOfficialStorageProvider(provider)) {
+        return {
+            label: OFFICIAL_STORAGE_PROVIDER_NAME,
+            storageConfigId: null,
+            aliasName: OFFICIAL_STORAGE_PROVIDER_NAME,
+            isOfficial: true,
+        };
+    }
+    const exactConfig = configsByKey.get(`${provider}::${bucket}`);
+    if (exactConfig?.aliasName) {
+        return {
+            label: exactConfig.aliasName,
+            storageConfigId: exactConfig.id,
+            aliasName: exactConfig.aliasName,
+            isOfficial: false,
+        };
+    }
+    const sameProviderConfigs = configsByProvider.get(provider) ?? [];
+    if (sameProviderConfigs.length === 1 && sameProviderConfigs[0]?.aliasName) {
+        return {
+            label: sameProviderConfigs[0].aliasName,
+            storageConfigId: sameProviderConfigs[0].id,
+            aliasName: sameProviderConfigs[0].aliasName,
+            isOfficial: false,
+        };
+    }
+    return {
+        label: bucket ? `${getStorageProviderName(provider)} · ${bucket}` : getStorageProviderName(provider),
+        storageConfigId: exactConfig?.id ?? null,
+        aliasName: exactConfig?.aliasName ?? null,
+        isOfficial: false,
+    };
+}
+async function getTableColumns(db, tableName) {
+    const rows = await db.getAll(`PRAGMA table_info(${tableName})`, []);
+    return new Set(rows.map((row) => row.name).filter(Boolean));
+}
+async function listStoredCustomStorageConfigs(db, userId) {
+    const rows = await db.getAll(`
+    SELECT
+      TRIM(COALESCE(id, '')) AS id,
+      TRIM(COALESCE(alias_name, '')) AS alias_name,
+      TRIM(COALESCE(protocol, '')) AS protocol,
+      TRIM(COALESCE(provider, '')) AS provider,
+      TRIM(COALESCE(endpoint, '')) AS endpoint,
+      TRIM(COALESCE(bucket, '')) AS bucket,
+      TRIM(COALESCE(region, '')) AS region,
+      TRIM(COALESCE(access_key_id, '')) AS access_key_id,
+      TRIM(COALESCE(secret_access_key, '')) AS secret_access_key,
+      force_path_style,
+      TRIM(COALESCE(path_prefix, '')) AS path_prefix,
+      TRIM(COALESCE(custom_domain, '')) AS custom_domain,
+      legacy_domains,
+      is_private,
+      updated_at,
+      deleted_at
+    FROM c_storage
+    WHERE TRIM(COALESCE(user_id, '')) = ?
+      AND TRIM(COALESCE(protocol, '')) = ?
+      AND deleted_at IS NULL
+      AND TRIM(COALESCE(id, '')) <> ''
+    ORDER BY COALESCE(sort_rank, 2147483647) ASC, updated_at DESC, id ASC
+    `, [userId, DEFAULT_STORAGE_PROTOCOL]);
+    return rows
+        .map((row) => ({
+        id: normalizeText(row.id),
+        aliasName: normalizeText(row.alias_name),
+        provider: normalizeText(row.provider),
+        endpoint: normalizeText(row.endpoint),
+        bucket: normalizeText(row.bucket),
+        region: normalizeText(row.region),
+        accessKeyId: normalizeText(row.access_key_id),
+        secretAccessKey: normalizeText(row.secret_access_key),
+        forcePathStyle: normalizeBool(row.force_path_style),
+        pathPrefix: normalizeStoragePathPrefix(normalizeText(row.path_prefix)),
+        customDomain: normalizeText(row.custom_domain),
+        legacyDomains: normalizeTextArray(row.legacy_domains),
+        isPrivate: normalizeBool(row.is_private),
+    }))
+        .filter((row) => row.id.length > 0);
+}
+async function getActiveCustomStorageConfigId(db, userId) {
+    const rows = await db.getAll(`
+    SELECT c_value
+    FROM c_config_property
+    WHERE TRIM(COALESCE(c_key, '')) = ?
+      AND TRIM(COALESCE(user_id, '')) = ?
+      AND (is_del IS NULL OR is_del = 0)
+    ORDER BY updated_at DESC, created_at DESC, id DESC
+    LIMIT 1
+    `, [ACTIVE_CUSTOM_STORAGE_CONFIG_ID_KEY, userId]);
+    return normalizeText(rows[0]?.c_value ?? null) || null;
+}
+function resolveStorageSelection(args) {
+    const explicitId = normalizeText(args.storageId);
+    if (explicitId) {
+        const config = args.configs.find((item) => item.id === explicitId);
+        if (!config) {
+            throw new DinoxError(`Storage config not found: ${explicitId}`, {
+                suggestion: 'Run `dino storage list --format json` to inspect available storage ids.',
+            });
+        }
+        return { config, selectionSource: 'storage_id' };
+    }
+    const activeId = normalizeText(args.activeCustomStorageConfigId);
+    if (activeId) {
+        const config = args.configs.find((item) => item.id === activeId);
+        if (config) {
+            return { config, selectionSource: 'active' };
+        }
+    }
+    if (args.configs.length === 1) {
+        return { config: args.configs[0], selectionSource: 'single_available_config' };
+    }
+    throw new DinoxError('No active custom storage config is available for upload.', {
+        suggestion: 'Set an active custom storage config in the app, or pass `--storage-id <id>`.',
+    });
+}
+function buildStorageUploadPlan(args) {
+    const storageKey = normalizeText(args.key) || `${args.config.pathPrefix}${buildObjectId(args.userId, args.category, args.filePath)}`;
+    const target = buildStorageTarget(args.config, storageKey);
+    return {
+        storage: toSanitizedStorage({
+            ...args.config,
+            endpoint: finishStorageHost(args.config.endpoint),
+        }, args.selectionSource === 'active'),
+        selectionSource: args.selectionSource,
+        filePath: args.filePath,
+        fileName: path.basename(args.filePath),
+        sizeBytes: args.sizeBytes,
+        category: args.category,
+        contentType: guessContentType(args.filePath),
+        storageKey,
+        storageUrl: target.storageUrl,
+        domain: target.domain,
+    };
+}
+function buildStorageTestPlan(args) {
+    const storageKey = `${args.config.pathPrefix}dinox-cli-test/${args.userId}/${generateId()}.txt`;
+    const target = buildStorageTarget(args.config, storageKey);
+    const payload = Buffer.from(`dinox-cli storage test\nprovider=${args.config.provider}\nuser=${args.userId}\ncreated_at=${new Date().toISOString()}\n`, 'utf8');
+    return {
+        storage: toSanitizedStorage({
+            ...args.config,
+            endpoint: finishStorageHost(args.config.endpoint),
+        }, args.selectionSource === 'active'),
+        selectionSource: args.selectionSource,
+        contentType: 'text/plain',
+        sizeBytes: payload.byteLength,
+        storageKey,
+        storageUrl: target.storageUrl,
+        domain: target.domain,
+    };
+}
+async function defaultUploadObject(input) {
+    const client = new S3Client({
+        endpoint: finishStorageHost(input.storage.endpoint),
+        region: input.storage.region,
+        forcePathStyle: input.storage.forcePathStyle,
+        credentials: {
+            accessKeyId: input.storage.accessKeyId,
+            secretAccessKey: input.storage.secretAccessKey,
+        },
+    });
+    const response = await client.send(new PutObjectCommand({
+        Bucket: input.bucket,
+        Key: input.key,
+        Body: fs.createReadStream(input.localPath),
+        ContentType: input.contentType,
+        ContentLength: input.contentLength,
+    }));
+    return {
+        etag: normalizeText(response.ETag) || null,
+    };
+}
+async function defaultDeleteObject(input) {
+    const client = new S3Client({
+        endpoint: finishStorageHost(input.storage.endpoint),
+        region: input.storage.region,
+        forcePathStyle: input.storage.forcePathStyle,
+        credentials: {
+            accessKeyId: input.storage.accessKeyId,
+            secretAccessKey: input.storage.secretAccessKey,
+        },
+    });
+    await client.send(new DeleteObjectCommand({
+        Bucket: input.bucket,
+        Key: input.key,
+    }));
+}
+async function defaultUploadBytes(input) {
+    const client = new S3Client({
+        endpoint: finishStorageHost(input.storage.endpoint),
+        region: input.storage.region,
+        forcePathStyle: input.storage.forcePathStyle,
+        credentials: {
+            accessKeyId: input.storage.accessKeyId,
+            secretAccessKey: input.storage.secretAccessKey,
+        },
+    });
+    const response = await client.send(new PutObjectCommand({
+        Bucket: input.bucket,
+        Key: input.key,
+        Body: input.body,
+        ContentType: input.contentType,
+        ContentLength: input.body.byteLength,
+    }));
+    return {
+        etag: normalizeText(response.ETag) || null,
+    };
+}
+async function generateThumbnailBuffer(localPath) {
+    return sharp(localPath)
+        .resize({ width: 400, withoutEnlargement: true })
+        .webp({ quality: 50 })
+        .toBuffer();
+}
+async function insertUploadedResource(db, args) {
+    const columns = await getTableColumns(db, 'c_resource');
+    const requiredColumns = [
+        'id',
+        'user_id',
+        'name',
+        'mime_type',
+        'size_bytes',
+        'storage_key',
+        'storage_url',
+        'storage_provider',
+        'bucket',
+        'created_at',
+        'updated_at',
+        'is_del',
+    ];
+    const missingRequired = requiredColumns.filter((column) => !columns.has(column));
+    if (missingRequired.length > 0) {
+        throw new DinoxError(`c_resource table is missing required columns: ${missingRequired.join(', ')}`);
+    }
+    const id = generateId();
+    const now = new Date().toISOString();
+    const insertEntries = [];
+    const pushInsert = (column, value) => {
+        if (columns.has(column)) {
+            insertEntries.push([column, value]);
+        }
+    };
+    pushInsert('id', id);
+    pushInsert('user_id', args.userId);
+    pushInsert('name', args.plan.fileName);
+    pushInsert('mime_type', args.plan.contentType);
+    pushInsert('size_bytes', args.plan.sizeBytes);
+    pushInsert('storage_config_id', args.storage.id);
+    pushInsert('storage_key', args.plan.storageKey);
+    pushInsert('storage_url', args.plan.storageUrl);
+    pushInsert('storage_provider', args.storage.provider);
+    pushInsert('bucket', args.storage.bucket);
+    pushInsert('is_public', args.storage.isPrivate ? 0 : 1);
+    pushInsert('created_at', now);
+    pushInsert('updated_at', now);
+    pushInsert('is_del', 0);
+    pushInsert('status', 'uploaded');
+    pushInsert('uploaded_at', now);
+    pushInsert('etag', args.etag);
+    pushInsert('checksum', args.thumbnailUrl);
+    pushInsert('category', args.plan.category);
+    pushInsert('endpoint', args.storage.endpoint);
+    pushInsert('domain', args.plan.domain);
+    pushInsert('extra_data', '{}');
+    pushInsert('deleted_at', null);
+    pushInsert('content_sha256', null);
+    pushInsert('content', null);
+    pushInsert('content_md', null);
+    pushInsert('summary', null);
+    const insertColumns = insertEntries.map(([column]) => column);
+    const placeholders = insertColumns.map(() => '?').join(', ');
+    const params = insertEntries.map(([, value]) => value);
+    await db.execute(`
+    INSERT INTO c_resource (${insertColumns.join(', ')})
+    VALUES (${placeholders})
+    `, params);
+    return id;
+}
+export function parseStorageUploadCategory(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (UPLOAD_CATEGORY_VALUES.includes(normalized)) {
+        return normalized;
+    }
+    throw new DinoxError(`--category must be one of: ${UPLOAD_CATEGORY_VALUES.join(', ')}`);
+}
+export async function listStorageConfigs(db, userId) {
+    const activeCustomStorageConfigId = await getActiveCustomStorageConfigId(db, userId);
+    const configs = await listStoredCustomStorageConfigs(db, userId);
+    return {
+        activeCustomStorageConfigId,
+        usesOfficialStorage: !activeCustomStorageConfigId,
+        items: configs.map((config) => toSanitizedStorage(config, config.id === activeCustomStorageConfigId)),
+    };
+}
+export async function getStorageStats(db, userId) {
+    const rows = await db.getAll(`
+    SELECT
+      TRIM(COALESCE(storage_provider, '')) AS provider,
+      TRIM(COALESCE(bucket, '')) AS bucket,
+      COALESCE(SUM(COALESCE(size_bytes, 0)), 0) AS total_bytes,
+      COUNT(1) AS file_count
+    FROM c_resource
+    WHERE (is_del IS NULL OR is_del = 0)
+      AND TRIM(COALESCE(storage_provider, '')) <> ''
+      AND TRIM(COALESCE(storage_provider, '')) <> 'local'
+      AND TRIM(COALESCE(status, '')) = 'uploaded'
+    GROUP BY storage_provider, bucket
+    ORDER BY total_bytes DESC, provider ASC, bucket ASC
+    `, []);
+    const configs = await listStoredCustomStorageConfigs(db, userId);
+    const configsByKey = new Map();
+    const configsByProvider = new Map();
+    for (const config of configs) {
+        configsByKey.set(`${config.provider}::${config.bucket}`, config);
+        const current = configsByProvider.get(config.provider);
+        if (current) {
+            current.push(config);
+        }
+        else {
+            configsByProvider.set(config.provider, [config]);
+        }
+    }
+    const entries = rows
+        .map((row) => {
+        const provider = normalizeText(row.provider);
+        const bucket = normalizeText(row.bucket);
+        const labelInfo = buildStorageUsageLabel({
+            provider,
+            bucket,
+            configsByKey,
+            configsByProvider,
+        });
+        return {
+            provider,
+            bucket,
+            label: labelInfo.label,
+            totalBytes: normalizeNumber(row.total_bytes),
+            fileCount: normalizeNumber(row.file_count),
+            storageConfigId: labelInfo.storageConfigId,
+            aliasName: labelInfo.aliasName,
+            isOfficial: labelInfo.isOfficial,
+        };
+    })
+        .filter((entry) => entry.provider.length > 0 && entry.fileCount > 0)
+        .sort((left, right) => {
+        if (left.isOfficial !== right.isOfficial) {
+            return left.isOfficial ? -1 : 1;
+        }
+        return right.totalBytes - left.totalBytes;
+    });
+    return {
+        totalBytes: entries.reduce((sum, entry) => sum + entry.totalBytes, 0),
+        totalFiles: entries.reduce((sum, entry) => sum + entry.fileCount, 0),
+        entries,
+    };
+}
+export async function inspectStorageUpload(db, input, deps) {
+    const statFile = deps?.statFile ?? fsp.stat;
+    const filePath = input.filePath.trim();
+    if (!filePath) {
+        throw new DinoxError('File path is required.');
+    }
+    const stats = await statFile(filePath).catch((error) => {
+        throw new DinoxError(`File not found: ${filePath}`, { cause: error });
+    });
+    if (!stats.isFile()) {
+        throw new DinoxError(`Not a regular file: ${filePath}`);
+    }
+    const configs = await listStoredCustomStorageConfigs(db, input.userId);
+    if (configs.length === 0) {
+        throw new DinoxError('No custom storage configs are available.', {
+            suggestion: 'Configure a custom storage target in the app first.',
+        });
+    }
+    const activeCustomStorageConfigId = await getActiveCustomStorageConfigId(db, input.userId);
+    const { config, selectionSource } = resolveStorageSelection({
+        configs,
+        storageId: input.storageId,
+        activeCustomStorageConfigId,
+    });
+    if (!config.endpoint || !config.bucket || !config.region || !config.accessKeyId || !config.secretAccessKey) {
+        throw new DinoxError(`Storage config "${config.aliasName || config.id}" is incomplete for upload.`, {
+            suggestion: 'Fill in endpoint, region, bucket, access key id, and secret access key in the app.',
+        });
+    }
+    return buildStorageUploadPlan({
+        config,
+        selectionSource,
+        userId: input.userId,
+        filePath,
+        category: input.category,
+        key: input.key,
+        sizeBytes: stats.size,
+    });
+}
+export async function inspectStorageTest(db, input) {
+    const configs = await listStoredCustomStorageConfigs(db, input.userId);
+    if (configs.length === 0) {
+        throw new DinoxError('No custom storage configs are available.', {
+            suggestion: 'Configure a custom storage target in the app first.',
+        });
+    }
+    const activeCustomStorageConfigId = await getActiveCustomStorageConfigId(db, input.userId);
+    const { config, selectionSource } = resolveStorageSelection({
+        configs,
+        storageId: input.storageId,
+        activeCustomStorageConfigId,
+    });
+    if (!config.endpoint || !config.bucket || !config.region || !config.accessKeyId || !config.secretAccessKey) {
+        throw new DinoxError(`Storage config "${config.aliasName || config.id}" is incomplete for upload.`, {
+            suggestion: 'Fill in endpoint, region, bucket, access key id, and secret access key in the app.',
+        });
+    }
+    return buildStorageTestPlan({
+        config,
+        selectionSource,
+        userId: input.userId,
+    });
+}
+export async function testStorageUpload(db, input, deps) {
+    const plan = await inspectStorageTest(db, input);
+    const configs = await listStoredCustomStorageConfigs(db, input.userId);
+    const storage = configs.find((item) => item.id === plan.storage.id);
+    if (!storage) {
+        throw new DinoxError(`Storage config not found: ${plan.storage.id}`);
+    }
+    const uploadBytes = deps?.uploadBytes ?? defaultUploadBytes;
+    const payload = Buffer.from(`dinox-cli storage test\nprovider=${storage.provider}\nuser=${input.userId}\ncreated_at=${new Date().toISOString()}\n`, 'utf8');
+    await uploadBytes({
+        body: payload,
+        bucket: storage.bucket,
+        key: plan.storageKey,
+        contentType: plan.contentType,
+        storage,
+    });
+    return {
+        storageConfigId: storage.id,
+        aliasName: storage.aliasName,
+        provider: storage.provider,
+        bucket: storage.bucket,
+        endpoint: storage.endpoint,
+        domain: plan.domain,
+        storageKey: plan.storageKey,
+        storageUrl: plan.storageUrl,
+        contentType: plan.contentType,
+        sizeBytes: plan.sizeBytes,
+        selectionSource: plan.selectionSource,
+        isPrivate: storage.isPrivate,
+    };
+}
+export async function uploadFileToStorage(db, input, deps) {
+    const plan = await inspectStorageUpload(db, input, { statFile: deps?.statFile });
+    const configs = await listStoredCustomStorageConfigs(db, input.userId);
+    const storage = configs.find((item) => item.id === plan.storage.id);
+    if (!storage) {
+        throw new DinoxError(`Storage config not found: ${plan.storage.id}`);
+    }
+    const uploadObject = deps?.uploadObject ?? defaultUploadObject;
+    const uploadBytes = deps?.uploadBytes ?? defaultUploadBytes;
+    const deleteObject = deps?.deleteObject ?? defaultDeleteObject;
+    const uploaded = await uploadObject({
+        localPath: plan.filePath,
+        bucket: storage.bucket,
+        key: plan.storageKey,
+        contentType: plan.contentType,
+        contentLength: plan.sizeBytes,
+        storage,
+    });
+    let thumbnailUrl = null;
+    let uploadedThumbnailKey = null;
+    try {
+        if (plan.contentType.startsWith('image/')) {
+            const thumbnailKey = generateThumbnailKey(plan.storageKey);
+            const thumbnailBuffer = await generateThumbnailBuffer(plan.filePath);
+            const thumbnailTarget = buildStorageTarget(storage, thumbnailKey);
+            await uploadBytes({
+                body: thumbnailBuffer,
+                bucket: storage.bucket,
+                key: thumbnailKey,
+                contentType: 'image/webp',
+                storage,
+            });
+            uploadedThumbnailKey = thumbnailKey;
+            thumbnailUrl = thumbnailTarget.storageUrl;
+        }
+        const resourceId = await insertUploadedResource(db, {
+            userId: input.userId,
+            storage,
+            plan,
+            etag: uploaded.etag,
+            thumbnailUrl,
+        });
+        return {
+            resourceId,
+            storageConfigId: storage.id,
+            aliasName: storage.aliasName,
+            provider: storage.provider,
+            bucket: storage.bucket,
+            endpoint: storage.endpoint,
+            domain: plan.domain,
+            storageKey: plan.storageKey,
+            storageUrl: plan.storageUrl,
+            fileName: plan.fileName,
+            sizeBytes: plan.sizeBytes,
+            contentType: plan.contentType,
+            category: plan.category,
+            etag: uploaded.etag,
+            thumbnailUrl,
+            isPrivate: storage.isPrivate,
+            selectionSource: plan.selectionSource,
+        };
+    }
+    catch (error) {
+        const cleanupErrors = [];
+        if (uploadedThumbnailKey) {
+            await deleteObject({
+                bucket: storage.bucket,
+                key: uploadedThumbnailKey,
+                storage,
+            }).catch((cleanupError) => {
+                cleanupErrors.push(`thumbnail cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            });
+        }
+        await deleteObject({
+            bucket: storage.bucket,
+            key: plan.storageKey,
+            storage,
+        }).catch((cleanupError) => {
+            cleanupErrors.push(`main object cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+        });
+        throw new DinoxError('Storage upload failed while generating the required thumbnail.', {
+            cause: error,
+            code: 'STORAGE_THUMBNAIL_UPLOAD_FAILED',
+            ...(cleanupErrors.length > 0 ? { details: { cleanupErrors } } : {}),
+        });
+    }
+}