@dinoxx/dinox-cli 1.1.1 → 2.1.0

package/dist/commands/storage/repo/configs.js

@@ -0,0 +1,259 @@
+// Custom storage config listing, selection, upload/test planning, and usage stats.
+import path from 'node:path';
+import { generateId } from '../../../utils/id.js';
+import { DinoxError } from '../../../utils/errors.js';
+import { ACTIVE_CUSTOM_STORAGE_CONFIG_ID_KEY, DEFAULT_STORAGE_PROTOCOL, OFFICIAL_STORAGE_PROVIDER_NAME, UPLOAD_CATEGORY_VALUES, normalizeBool, normalizeNumber, normalizeText, normalizeTextArray, } from './shared.js';
+import { buildObjectId, buildStorageTarget, finishStorageHost, getStorageProviderName, guessContentType, isOfficialStorageProvider, normalizeStoragePathPrefix, } from './targets.js';
+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,
+    };
+}
+export async function getTableColumns(db, tableName) {
+    const rows = await db.getAll(`PRAGMA table_info(${tableName})`, []);
+    return new Set(rows.map((row) => row.name).filter(Boolean));
+}
+export 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);
+}
+export 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;
+}
+export 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>`.',
+    });
+}
+export 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,
+    };
+}
+export 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,
+    };
+}
+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(user_id, '')) = ?
+      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
+    `, [userId]);
+    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,
+    };
+}

package/dist/commands/storage/repo/operations.d.ts

@@ -0,0 +1,25 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type StorageTestPlan, type StorageTestResult, type StorageUploadCategory, type StorageUploadPlan, type StorageUploadResult, type UploadDeps } from './shared.js';
+export declare function inspectStorageUpload(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    filePath: string;
+    category: StorageUploadCategory;
+    storageId?: string;
+    key?: string;
+}, deps?: Pick<UploadDeps, 'statFile'>): Promise<StorageUploadPlan>;
+export declare function inspectStorageTest(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    storageId?: string;
+}): Promise<StorageTestPlan>;
+export declare function testStorageUpload(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    storageId?: string;
+}, deps?: Pick<UploadDeps, 'deleteObject' | 'uploadBytes'>): Promise<StorageTestResult>;
+export declare function uploadFileToStorage(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    filePath: string;
+    category: StorageUploadCategory;
+    storageId?: string;
+    key?: string;
+    overwrite?: boolean;
+}, deps?: UploadDeps): Promise<StorageUploadResult>;

package/dist/commands/storage/repo/operations.js

@@ -0,0 +1,337 @@
+// Storage commands: inspect/test/upload orchestration with cleanup on partial failure.
+import fsp from 'node:fs/promises';
+import { DinoxError } from '../../../utils/errors.js';
+import { buildStorageTestPlan, buildStorageUploadPlan, getActiveCustomStorageConfigId, listStoredCustomStorageConfigs, resolveStorageSelection, } from './configs.js';
+import { createStorageCollisionError, createStorageUploadOutcomeUnknownError, defaultDeleteObject, defaultUploadBytes, defaultUploadObject, generateThumbnailBuffer, isObjectCollisionError, loadSharp, } from './remote.js';
+import { normalizeText, } from './shared.js';
+import { persistUploadedResource } from './resources.js';
+import { buildStorageTarget, generateThumbnailKey } from './targets.js';
+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 deleteObject = deps?.deleteObject ?? defaultDeleteObject;
+    const payload = Buffer.from(`dinox-cli storage test\nprovider=${storage.provider}\nuser=${input.userId}\ncreated_at=${new Date().toISOString()}\n`, 'utf8');
+    let uploaded;
+    try {
+        uploaded = await uploadBytes({
+            body: payload,
+            bucket: storage.bucket,
+            key: plan.storageKey,
+            contentType: plan.contentType,
+            storage,
+        });
+    }
+    catch (error) {
+        if (isObjectCollisionError(error)) {
+            throw error;
+        }
+        throw createStorageUploadOutcomeUnknownError({
+            message: 'Storage test upload outcome could not be confirmed.',
+            cause: error,
+            bucket: storage.bucket,
+            storageKey: plan.storageKey,
+            possiblyAffectedKeys: [plan.storageKey],
+            overwrite: false,
+            operation: 'storage_test',
+        });
+    }
+    const cleanupEtag = normalizeText(uploaded.etag);
+    if (!cleanupEtag) {
+        throw new DinoxError('Storage test uploaded the temporary object but could not clean it up safely.', {
+            code: 'STORAGE_TEST_CLEANUP_FAILED',
+            details: {
+                storageKey: plan.storageKey,
+                bucket: storage.bucket,
+                remoteObjectChanged: true,
+                affectedKeys: [plan.storageKey],
+                cleanupErrors: [
+                    `${plan.storageKey} cleanup skipped: upload response did not include an ETag required for safe conditional deletion`,
+                ],
+            },
+        });
+    }
+    try {
+        await deleteObject({
+            bucket: storage.bucket,
+            key: plan.storageKey,
+            etag: cleanupEtag,
+            storage,
+        });
+    }
+    catch (error) {
+        throw new DinoxError('Storage test uploaded the temporary object but failed to clean it up.', {
+            cause: error,
+            code: 'STORAGE_TEST_CLEANUP_FAILED',
+            details: {
+                storageKey: plan.storageKey,
+                bucket: storage.bucket,
+                remoteObjectChanged: true,
+                affectedKeys: [plan.storageKey],
+                cleanupErrors: [
+                    `${plan.storageKey} cleanup failed: ${error instanceof Error ? error.message : String(error)}`,
+                ],
+            },
+        });
+    }
+    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) {
+    if (input.overwrite && !normalizeText(input.key)) {
+        throw new DinoxError('--overwrite requires an explicit --key.', {
+            code: 'USAGE_ERROR',
+        });
+    }
+    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 overwrite = input.overwrite === true;
+    const uploadObject = deps?.uploadObject ?? defaultUploadObject;
+    const uploadBytes = deps?.uploadBytes ?? defaultUploadBytes;
+    const deleteObject = deps?.deleteObject ?? defaultDeleteObject;
+    const thumbnailKey = plan.contentType.startsWith('image/')
+        ? generateThumbnailKey(plan.storageKey)
+        : null;
+    // Fail before any remote write when the required thumbnail cannot be produced.
+    const sharp = plan.contentType.startsWith('image/') ? await loadSharp() : null;
+    let uploaded;
+    try {
+        uploaded = await uploadObject({
+            localPath: plan.filePath,
+            bucket: storage.bucket,
+            key: plan.storageKey,
+            contentType: plan.contentType,
+            contentLength: plan.sizeBytes,
+            overwrite,
+            storage,
+        });
+    }
+    catch (error) {
+        if (!overwrite && isObjectCollisionError(error)) {
+            throw createStorageCollisionError(storage.bucket, [plan.storageKey]);
+        }
+        throw createStorageUploadOutcomeUnknownError({
+            message: 'Storage upload outcome could not be confirmed.',
+            cause: error,
+            bucket: storage.bucket,
+            storageKey: plan.storageKey,
+            possiblyAffectedKeys: [plan.storageKey],
+            overwrite,
+            operation: 'upload',
+        });
+    }
+    let thumbnailUrl = null;
+    const possiblyAffectedKeys = new Set();
+    const remoteWrites = [{
+            key: plan.storageKey,
+            etag: uploaded.etag,
+            cleanupAllowed: !overwrite,
+            cleaned: false,
+        }];
+    const cleanupUploadedObjects = async () => {
+        const cleanupErrors = [];
+        for (const remoteWrite of [...remoteWrites].reverse()) {
+            if (!remoteWrite.cleanupAllowed || remoteWrite.cleaned) {
+                continue;
+            }
+            const cleanupEtag = normalizeText(remoteWrite.etag);
+            if (!cleanupEtag) {
+                cleanupErrors.push(`${remoteWrite.key} cleanup skipped: upload response did not include an ETag required for safe conditional deletion`);
+                continue;
+            }
+            await deleteObject({
+                bucket: storage.bucket,
+                key: remoteWrite.key,
+                etag: cleanupEtag,
+                storage,
+            }).then(() => {
+                remoteWrite.cleaned = true;
+            }, (cleanupError) => {
+                cleanupErrors.push(`${remoteWrite.key} cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            });
+        }
+        return cleanupErrors;
+    };
+    const buildRemoteFailureDetails = (cleanupErrors) => {
+        const affectedKeys = remoteWrites
+            .filter((remoteWrite) => !remoteWrite.cleaned)
+            .map((remoteWrite) => remoteWrite.key);
+        const possibleKeys = [...possiblyAffectedKeys];
+        return {
+            bucket: storage.bucket,
+            storageKey: plan.storageKey,
+            remoteObjectChanged: possibleKeys.length > 0
+                ? (affectedKeys.length > 0 ? true : null)
+                : affectedKeys.length > 0,
+            affectedKeys,
+            ...(possibleKeys.length > 0
+                ? { remoteOutcome: 'unknown', possiblyAffectedKeys: possibleKeys }
+                : {}),
+            ...(cleanupErrors.length > 0 ? { cleanupErrors } : {}),
+        };
+    };
+    if (plan.contentType.startsWith('image/')) {
+        try {
+            if (!thumbnailKey || !sharp) {
+                throw new Error('Thumbnail key could not be generated.');
+            }
+            const thumbnailBuffer = await generateThumbnailBuffer(sharp, plan.filePath);
+            const thumbnailTarget = buildStorageTarget(storage, thumbnailKey);
+            let uploadedThumbnail;
+            try {
+                uploadedThumbnail = await uploadBytes({
+                    body: thumbnailBuffer,
+                    bucket: storage.bucket,
+                    key: thumbnailKey,
+                    contentType: 'image/webp',
+                    overwrite,
+                    storage,
+                });
+            }
+            catch (error) {
+                if (!isObjectCollisionError(error)) {
+                    possiblyAffectedKeys.add(thumbnailKey);
+                }
+                throw error;
+            }
+            remoteWrites.push({
+                key: thumbnailKey,
+                etag: uploadedThumbnail.etag,
+                cleanupAllowed: !overwrite,
+                cleaned: false,
+            });
+            thumbnailUrl = thumbnailTarget.storageUrl;
+        }
+        catch (error) {
+            const cleanupErrors = await cleanupUploadedObjects();
+            if (!overwrite && isObjectCollisionError(error) && thumbnailKey) {
+                throw createStorageCollisionError(storage.bucket, [thumbnailKey], buildRemoteFailureDetails(cleanupErrors));
+            }
+            throw new DinoxError('Storage upload failed while generating the required thumbnail.', {
+                cause: error,
+                code: 'STORAGE_THUMBNAIL_UPLOAD_FAILED',
+                details: buildRemoteFailureDetails(cleanupErrors),
+            });
+        }
+    }
+    try {
+        const resourceId = await persistUploadedResource(db, {
+            userId: input.userId,
+            storage,
+            plan,
+            etag: uploaded.etag,
+            thumbnailUrl,
+            overwrite,
+        });
+        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 = await cleanupUploadedObjects();
+        throw new DinoxError('Storage upload failed while recording resource metadata.', {
+            cause: error,
+            code: 'STORAGE_RESOURCE_INSERT_FAILED',
+            details: buildRemoteFailureDetails(cleanupErrors),
+        });
+    }
+}

package/dist/commands/storage/repo/remote.d.ts

@@ -0,0 +1,32 @@
+import { DinoxError } from '../../../utils/errors.js';
+import { type StoredCustomStorageConfig, type UploadObjectInput, type UploadObjectResult } from './shared.js';
+export declare function defaultUploadObject(input: UploadObjectInput): Promise<UploadObjectResult>;
+export declare function isObjectCollisionError(error: unknown): boolean;
+export declare function createStorageCollisionError(bucket: string, keys: string[], failureDetails?: Record<string, unknown>): DinoxError;
+export declare function createStorageUploadOutcomeUnknownError(input: {
+    message: string;
+    cause: unknown;
+    bucket: string;
+    storageKey: string;
+    possiblyAffectedKeys: string[];
+    overwrite: boolean;
+    operation: 'upload' | 'storage_test';
+}): DinoxError;
+export declare function defaultDeleteObject(input: {
+    bucket: string;
+    key: string;
+    etag?: string | null;
+    storage: StoredCustomStorageConfig;
+}): Promise<void>;
+export declare function defaultUploadBytes(input: {
+    body: Buffer;
+    bucket: string;
+    key: string;
+    contentType: string;
+    overwrite?: boolean;
+    storage: StoredCustomStorageConfig;
+}): Promise<UploadObjectResult>;
+type SharpFactory = typeof import('sharp');
+export declare function loadSharp(): Promise<SharpFactory>;
+export declare function generateThumbnailBuffer(sharp: SharpFactory, localPath: string): Promise<Buffer>;
+export {};