@dinoxx/dinox-cli 2.0.0 → 2.1.1

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

@@ -0,0 +1,132 @@
+// S3 object operations, collision/unknown-outcome errors, and thumbnail rendering.
+import fs from 'node:fs';
+import { DinoxError } from '../../../utils/errors.js';
+import { normalizeText, } from './shared.js';
+import { finishStorageHost } from './targets.js';
+export async function defaultUploadObject(input) {
+    const { PutObjectCommand, S3Client } = await import('@aws-sdk/client-s3');
+    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,
+        IfNoneMatch: input.overwrite ? undefined : '*',
+    }));
+    return {
+        etag: normalizeText(response.ETag) || null,
+    };
+}
+export function isObjectCollisionError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const record = error;
+    return record.$metadata?.httpStatusCode === 409
+        || record.$metadata?.httpStatusCode === 412
+        || record.name === 'ConditionalRequestConflict'
+        || record.name === 'PreconditionFailed'
+        || record.Code === 'PreconditionFailed'
+        || record.code === 'PreconditionFailed';
+}
+export function createStorageCollisionError(bucket, keys, failureDetails = {}) {
+    return new DinoxError(`Storage object already exists: ${keys.join(', ')}`, {
+        code: 'STORAGE_OBJECT_ALREADY_EXISTS',
+        suggestion: 'Choose a different --key, or pass --overwrite to replace the existing object.',
+        recoverable: true,
+        details: {
+            bucket,
+            keys,
+            ...failureDetails,
+        },
+    });
+}
+export function createStorageUploadOutcomeUnknownError(input) {
+    return new DinoxError(input.message, {
+        cause: input.cause,
+        code: 'STORAGE_UPLOAD_OUTCOME_UNKNOWN',
+        recoverable: true,
+        suggestion: 'Inspect the reported object key in remote storage before retrying; do not assume the failed request left the object unchanged.',
+        details: {
+            bucket: input.bucket,
+            storageKey: input.storageKey,
+            operation: input.operation,
+            overwrite: input.overwrite,
+            remoteOutcome: 'unknown',
+            remoteObjectChanged: null,
+            affectedKeys: [],
+            possiblyAffectedKeys: [...new Set(input.possiblyAffectedKeys)],
+        },
+    });
+}
+export async function defaultDeleteObject(input) {
+    const { DeleteObjectCommand, S3Client } = await import('@aws-sdk/client-s3');
+    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,
+        IfMatch: normalizeText(input.etag) || undefined,
+    }));
+}
+export async function defaultUploadBytes(input) {
+    const { PutObjectCommand, S3Client } = await import('@aws-sdk/client-s3');
+    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,
+        IfNoneMatch: input.overwrite ? undefined : '*',
+    }));
+    return {
+        etag: normalizeText(response.ETag) || null,
+    };
+}
+// sharp is an optional native dependency: when it failed to install, the rest of the CLI
+// still works and only image uploads (which require a thumbnail) are refused up front.
+export async function loadSharp() {
+    try {
+        const { default: sharp } = await import('sharp');
+        return sharp;
+    }
+    catch (error) {
+        throw new DinoxError('Image uploads need the optional `sharp` image library, which is not installed or failed to load.', {
+            code: 'STORAGE_IMAGE_PROCESSING_UNAVAILABLE',
+            cause: error,
+            suggestion: 'Reinstall the CLI with optional dependencies enabled (for example `npm install -g @dinoxx/dinox-cli --include=optional`), then retry the upload.',
+            recoverable: true,
+        });
+    }
+}
+export async function generateThumbnailBuffer(sharp, localPath) {
+    return sharp(localPath)
+        .resize({ width: 400, withoutEnlargement: true })
+        .webp({ quality: 50 })
+        .toBuffer();
+}

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

@@ -0,0 +1,12 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type StorageUploadPlan, type StoredCustomStorageConfig } from './shared.js';
+type UploadedResourceWriteArgs = {
+    userId: string;
+    storage: StoredCustomStorageConfig;
+    plan: StorageUploadPlan;
+    etag: string | null;
+    thumbnailUrl: string | null;
+    overwrite: boolean;
+};
+export declare function persistUploadedResource(db: AbstractPowerSyncDatabase, args: UploadedResourceWriteArgs): Promise<string>;
+export {};

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

@@ -0,0 +1,134 @@
+// Recording uploaded objects as c_resource rows.
+import { withPowerSyncWriteTransaction } from '../../../powersync/runtime.js';
+import { generateId } from '../../../utils/id.js';
+import { DinoxError } from '../../../utils/errors.js';
+import { normalizeText, } from './shared.js';
+import { getTableColumns } from './configs.js';
+function buildUploadedResourceEntries(columns, args, id, now) {
+    const entries = [];
+    const push = (column, value) => {
+        if (columns.has(column)) {
+            entries.push([column, value]);
+        }
+    };
+    push('id', id);
+    push('user_id', args.userId);
+    push('name', args.plan.fileName);
+    push('mime_type', args.plan.contentType);
+    push('size_bytes', args.plan.sizeBytes);
+    push('storage_config_id', args.storage.id);
+    push('storage_key', args.plan.storageKey);
+    push('storage_url', args.plan.storageUrl);
+    push('storage_provider', args.storage.provider);
+    push('bucket', args.storage.bucket);
+    push('is_public', args.storage.isPrivate ? 0 : 1);
+    push('created_at', now);
+    push('updated_at', now);
+    push('is_del', 0);
+    push('status', 'uploaded');
+    push('uploaded_at', now);
+    push('etag', args.etag);
+    push('checksum', null);
+    push('category', args.plan.category);
+    push('endpoint', args.storage.endpoint);
+    push('domain', args.plan.domain);
+    push('extra_data', '{}');
+    push('deleted_at', null);
+    push('content_sha256', null);
+    push('content', null);
+    push('content_md', null);
+    push('summary', null);
+    return entries;
+}
+async function insertResourceRow(db, entries) {
+    const insertColumns = entries.map(([column]) => column);
+    const placeholders = insertColumns.map(() => '?').join(', ');
+    await db.execute(`
+    INSERT INTO c_resource (${insertColumns.join(', ')})
+    VALUES (${placeholders})
+    `, entries.map(([, value]) => value));
+}
+export async function persistUploadedResource(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 entries = buildUploadedResourceEntries(columns, args, id, now);
+    if (!args.overwrite) {
+        await insertResourceRow(db, entries);
+        return id;
+    }
+    return withPowerSyncWriteTransaction(db, async (tx) => {
+        const identityClauses = [
+            'user_id = ?',
+            'storage_key = ?',
+            'COALESCE(is_del, 0) = 0',
+        ];
+        const identityParams = [args.userId, args.plan.storageKey];
+        if (columns.has('storage_config_id')) {
+            identityClauses.push('storage_config_id = ?');
+            identityParams.push(args.storage.id);
+        }
+        else {
+            identityClauses.push('storage_provider = ?', 'bucket = ?');
+            identityParams.push(args.storage.provider, args.storage.bucket);
+            if (columns.has('endpoint')) {
+                identityClauses.push('endpoint = ?');
+                identityParams.push(args.storage.endpoint);
+            }
+        }
+        const existingRows = await tx.getAll(`
+      SELECT id
+      FROM c_resource
+      WHERE ${identityClauses.join('\n        AND ')}
+      ORDER BY created_at ASC, id ASC
+      `, identityParams);
+        const existingIds = [...new Set(existingRows.map((row) => normalizeText(row.id)).filter(Boolean))];
+        const existingId = existingIds[0];
+        if (!existingId) {
+            await insertResourceRow(tx, entries);
+            return id;
+        }
+        const updateEntries = entries.filter(([column]) => (column !== 'id' && column !== 'user_id' && column !== 'created_at'));
+        await tx.execute(`
+      UPDATE c_resource
+      SET ${updateEntries.map(([column]) => `${column} = ?`).join(', ')}
+      WHERE id = ?
+        AND user_id = ?
+        AND COALESCE(is_del, 0) = 0
+      `, [...updateEntries.map(([, value]) => value), existingId, args.userId]);
+        const duplicateIds = existingIds.slice(1);
+        if (duplicateIds.length > 0) {
+            const duplicateUpdates = [
+                ['updated_at', now],
+                ['is_del', 1],
+                ...(columns.has('deleted_at') ? [['deleted_at', now]] : []),
+            ];
+            await tx.execute(`
+        UPDATE c_resource
+        SET ${duplicateUpdates.map(([column]) => `${column} = ?`).join(', ')}
+        WHERE user_id = ?
+          AND COALESCE(is_del, 0) = 0
+          AND id IN (${duplicateIds.map(() => '?').join(', ')})
+        `, [...duplicateUpdates.map(([, value]) => value), args.userId, ...duplicateIds]);
+        }
+        return existingId;
+    });
+}

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

@@ -0,0 +1,181 @@
+import fsp from 'node:fs/promises';
+export declare const ACTIVE_CUSTOM_STORAGE_CONFIG_ID_KEY = "storage:active_custom_config_id";
+export declare const DEFAULT_STORAGE_PROTOCOL = "s3";
+export declare const DEFAULT_STORAGE_PATH_PREFIX = "dinox_note/";
+export declare const DEFAULT_CONTENT_TYPE = "application/octet-stream";
+export declare const OFFICIAL_STORAGE_PROVIDER = "aliyun-official";
+export declare const OFFICIAL_STORAGE_PROVIDER_NAME = "\u5B98\u65B9\u4E91";
+export declare const UPLOAD_CATEGORY_VALUES: readonly ["images", "audios", "files", "videos"];
+export type StorageUploadCategory = (typeof UPLOAD_CATEGORY_VALUES)[number];
+export type StorageListItem = {
+    id: string;
+    aliasName: string;
+    provider: string;
+    endpoint: string;
+    bucket: string;
+    region: string;
+    forcePathStyle: boolean;
+    pathPrefix: string;
+    customDomain: string;
+    legacyDomains: string[];
+    isPrivate: boolean;
+    hasAccessKeyId: boolean;
+    hasSecretAccessKey: boolean;
+    isActive: boolean;
+};
+export type StorageListResult = {
+    activeCustomStorageConfigId: string | null;
+    usesOfficialStorage: boolean;
+    items: StorageListItem[];
+};
+export type StorageRow = {
+    id: string | null;
+    alias_name: string | null;
+    protocol: string | null;
+    provider: string | null;
+    endpoint: string | null;
+    bucket: string | null;
+    region: string | null;
+    access_key_id: string | null;
+    secret_access_key: string | null;
+    force_path_style: number | null;
+    path_prefix: string | null;
+    custom_domain: string | null;
+    legacy_domains: string | null;
+    is_private: number | null;
+    updated_at: string | null;
+    deleted_at: string | null;
+};
+export type ConfigPropertyRow = {
+    c_value: string | null;
+};
+export type TableInfoRow = {
+    name: string;
+};
+export type StoredCustomStorageConfig = {
+    id: string;
+    aliasName: string;
+    provider: string;
+    endpoint: string;
+    bucket: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    forcePathStyle: boolean;
+    pathPrefix: string;
+    customDomain: string;
+    legacyDomains: string[];
+    isPrivate: boolean;
+};
+export type StorageUploadPlan = {
+    storage: StorageListItem;
+    selectionSource: 'storage_id' | 'active' | 'single_available_config';
+    filePath: string;
+    fileName: string;
+    sizeBytes: number;
+    category: StorageUploadCategory;
+    contentType: string;
+    storageKey: string;
+    storageUrl: string;
+    domain: string;
+};
+export type StorageUploadResult = {
+    resourceId: string;
+    storageConfigId: string;
+    aliasName: string;
+    provider: string;
+    bucket: string;
+    endpoint: string;
+    domain: string;
+    storageKey: string;
+    storageUrl: string;
+    fileName: string;
+    sizeBytes: number;
+    contentType: string;
+    category: StorageUploadCategory;
+    etag: string | null;
+    thumbnailUrl: string | null;
+    isPrivate: boolean;
+    selectionSource: StorageUploadPlan['selectionSource'];
+};
+export type StorageTestPlan = {
+    storage: StorageListItem;
+    selectionSource: StorageUploadPlan['selectionSource'];
+    contentType: string;
+    sizeBytes: number;
+    storageKey: string;
+    storageUrl: string;
+    domain: string;
+};
+export type StorageTestResult = {
+    storageConfigId: string;
+    aliasName: string;
+    provider: string;
+    bucket: string;
+    endpoint: string;
+    domain: string;
+    storageKey: string;
+    storageUrl: string;
+    contentType: string;
+    sizeBytes: number;
+    selectionSource: StorageUploadPlan['selectionSource'];
+    isPrivate: boolean;
+};
+export type StorageStatsEntry = {
+    provider: string;
+    bucket: string;
+    label: string;
+    totalBytes: number;
+    fileCount: number;
+    storageConfigId: string | null;
+    aliasName: string | null;
+    isOfficial: boolean;
+};
+export type StorageStatsResult = {
+    totalBytes: number;
+    totalFiles: number;
+    entries: StorageStatsEntry[];
+};
+export type UploadObjectInput = {
+    localPath: string;
+    bucket: string;
+    key: string;
+    contentType: string;
+    contentLength: number;
+    overwrite: boolean;
+    storage: StoredCustomStorageConfig;
+};
+export type UploadObjectResult = {
+    etag: string | null;
+};
+export type UploadDeps = {
+    statFile?: typeof fsp.stat;
+    uploadObject?: (input: UploadObjectInput) => Promise<UploadObjectResult>;
+    deleteObject?: (input: {
+        bucket: string;
+        key: string;
+        etag?: string | null;
+        storage: StoredCustomStorageConfig;
+    }) => Promise<void>;
+    uploadBytes?: (input: {
+        body: Buffer;
+        bucket: string;
+        key: string;
+        contentType: string;
+        overwrite?: boolean;
+        storage: StoredCustomStorageConfig;
+    }) => Promise<UploadObjectResult>;
+};
+export type StorageStatsRow = {
+    provider: string | null;
+    bucket: string | null;
+    total_bytes: number | string | null;
+    file_count: number | string | null;
+};
+export type ActiveResourceRow = {
+    id: string | null;
+};
+export declare function normalizeText(value: unknown): string;
+export declare function normalizeTextArray(raw: string | null): string[];
+export declare function normalizeBool(value: number | null): boolean;
+export declare function normalizeNumber(value: unknown): number;

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

@@ -0,0 +1,36 @@
+// Constants, row/result types, and value normalizers shared by the storage modules.
+export const ACTIVE_CUSTOM_STORAGE_CONFIG_ID_KEY = 'storage:active_custom_config_id';
+export const DEFAULT_STORAGE_PROTOCOL = 's3';
+export const DEFAULT_STORAGE_PATH_PREFIX = 'dinox_note/';
+export const DEFAULT_CONTENT_TYPE = 'application/octet-stream';
+export const OFFICIAL_STORAGE_PROVIDER = 'aliyun-official';
+export const OFFICIAL_STORAGE_PROVIDER_NAME = '官方云';
+export const UPLOAD_CATEGORY_VALUES = ['images', 'audios', 'files', 'videos'];
+export function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+export 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 [];
+    }
+}
+export function normalizeBool(value) {
+    return Number(value ?? 0) === 1;
+}
+export function normalizeNumber(value) {
+    const numeric = typeof value === 'number' ? value : Number(value ?? 0);
+    return Number.isFinite(numeric) ? numeric : 0;
+}

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

@@ -0,0 +1,12 @@
+import { type StorageUploadCategory, type StoredCustomStorageConfig } from './shared.js';
+export declare function normalizeStoragePathPrefix(value: string): string;
+export declare function finishStorageHost(value: string): string;
+export declare function guessContentType(filePath: string): string;
+export declare function buildObjectId(userId: string, category: StorageUploadCategory, filePath: string): string;
+export declare function generateThumbnailKey(originalKey: string): string;
+export declare function buildStorageTarget(config: StoredCustomStorageConfig, key: string): {
+    storageUrl: string;
+    domain: string;
+};
+export declare function isOfficialStorageProvider(provider: string): boolean;
+export declare function getStorageProviderName(provider: string): string;

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

@@ -0,0 +1,178 @@
+// Object keys, public URLs, content types, and provider naming for storage targets.
+import path from 'node:path';
+import { generateId } from '../../../utils/id.js';
+import { DinoxError } from '../../../utils/errors.js';
+import { DEFAULT_CONTENT_TYPE, DEFAULT_STORAGE_PATH_PREFIX, OFFICIAL_STORAGE_PROVIDER, OFFICIAL_STORAGE_PROVIDER_NAME, } from './shared.js';
+export function normalizeStoragePathPrefix(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return DEFAULT_STORAGE_PATH_PREFIX;
+    }
+    return trimmed.endsWith('/') ? trimmed : `${trimmed}/`;
+}
+export 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 encodeStorageKeyForUrl(key) {
+    return key
+        .split('/')
+        .map((segment) => {
+        return encodeURIComponent(segment).replace(/[!'()*]/g, (character) => {
+            return `%${character.charCodeAt(0).toString(16).toUpperCase()}`;
+        });
+    })
+        .join('/');
+}
+function assertStorageKeyUrlSafe(key) {
+    const unsafeSegment = key.split('/').find((segment) => segment === '.' || segment === '..');
+    if (!unsafeSegment) {
+        return;
+    }
+    throw new DinoxError('Storage object key must not contain "." or ".." path segments.', {
+        code: 'INVALID_STORAGE_KEY',
+        suggestion: 'Remove dot-only path segments from --key or the configured storage path prefix.',
+        details: { key },
+    });
+}
+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}`;
+    const encodedKey = encodeStorageKeyForUrl(key);
+    return {
+        finalUrl: `${protocol}//${hostWithBucket}${port}/${encodedKey}`,
+        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;
+    const encodedKey = encodeStorageKeyForUrl(key);
+    return {
+        finalUrl: `${protocol}//${host}${port}/${bucket}/${encodedKey}`,
+        domain: `${protocol}//${host}${port}`,
+    };
+}
+function getFileExtension(filePath) {
+    const extension = path.extname(filePath).trim().replace(/^\./, '');
+    return extension.toLowerCase();
+}
+export 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;
+    }
+}
+export function buildObjectId(userId, category, filePath) {
+    const ext = getFileExtension(filePath);
+    const suffix = ext ? `.${ext}` : '';
+    return `assets/${userId}/${category}/${generateId()}${suffix}`;
+}
+export 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`;
+}
+export function buildStorageTarget(config, key) {
+    assertStorageKeyUrlSafe(key);
+    const resolvedEndpoint = finishStorageHost(config.endpoint);
+    if (config.customDomain) {
+        const domain = finishStorageHost(config.customDomain);
+        return {
+            storageUrl: `${domain}/${encodeStorageKeyForUrl(key)}`,
+            domain,
+        };
+    }
+    const target = config.forcePathStyle
+        ? buildPathStyleUrl(config.bucket, resolvedEndpoint, key)
+        : buildVirtualHostedStyleUrl(config.bucket, resolvedEndpoint, key);
+    return {
+        storageUrl: target.finalUrl,
+        domain: target.domain,
+    };
+}
+export function isOfficialStorageProvider(provider) {
+    return provider === OFFICIAL_STORAGE_PROVIDER;
+}
+export 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;
+    }
+}