@cloudbase/storage 2.23.4-alpha.0 → 2.24.0

package/dist/cjs/supabase/index.js

@@ -0,0 +1,689 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseFileAPILikeStorage = void 0;
+var utilities_1 = require("@cloudbase/utilities");
+var storage_1 = require("../storage");
+var errors_1 = require("./errors");
+var ERRORS = utilities_1.constants.ERRORS;
+var SupabaseFileAPILikeStorage = (function (_super) {
+    __extends(SupabaseFileAPILikeStorage, _super);
+    function SupabaseFileAPILikeStorage() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.shouldThrowOnError = false;
+        _this.bucketId = '';
+        return _this;
+    }
+    SupabaseFileAPILikeStorage.prototype.throwOnError = function () {
+        this.shouldThrowOnError = true;
+        return this;
+    };
+    SupabaseFileAPILikeStorage.prototype.from = function (bucket) {
+        this.bucketId = bucket || '';
+        return this;
+    };
+    SupabaseFileAPILikeStorage.prototype.upload = function (path, fileBody, fileOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var options, cacheControl, contentType, metadata, cloudPath, uploadFileParams, headers, result, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = __assign({ upsert: true }, fileOptions);
+                        cacheControl = options.cacheControl, contentType = options.contentType, metadata = options.metadata;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        cloudPath = this._getCloudPath(path);
+                        uploadFileParams = {
+                            cloudPath: cloudPath,
+                            filePath: fileBody,
+                        };
+                        if (cacheControl || contentType || metadata) {
+                            headers = {};
+                            if (cacheControl) {
+                                headers['cache-control'] = cacheControl;
+                            }
+                            if (contentType) {
+                                headers['content-type'] = contentType;
+                            }
+                            if (metadata) {
+                                headers['x-cos-metadata-metadata'] = this.toBase64(JSON.stringify(metadata));
+                            }
+                            uploadFileParams.headers = headers;
+                        }
+                        return [4, this.uploadFile(uploadFileParams)];
+                    case 2:
+                        result = _a.sent();
+                        if (!result.fileID) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.OPERATION_FAIL,
+                                msg: "[".concat(storage_1.COMPONENT_NAME, ".update] no fileID returned"),
+                            }));
+                        }
+                        return [2, {
+                                data: {
+                                    id: result.fileID,
+                                    path: path,
+                                    fullPath: path,
+                                },
+                                error: null,
+                            }];
+                    case 3:
+                        error_1 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_1;
+                        if ((0, errors_1.isStorageError)(error_1)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_1,
+                                }];
+                        }
+                        throw error_1;
+                    case 4: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.uploadToSignedUrl = function (path, _token, fileBody, fileOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.upload(path, fileBody, fileOptions)];
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.createSignedUploadUrl = function (path) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cloudPath, metadata, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        cloudPath = this._getCloudPath(path);
+                        return [4, this.getUploadMetadata({ cloudPath: cloudPath })];
+                    case 1:
+                        metadata = (_a.sent()).data;
+                        return [2, {
+                                data: {
+                                    signedUrl: metadata.url,
+                                    token: metadata.token,
+                                    path: path,
+                                    authorization: metadata.authorization,
+                                    id: metadata.fileId,
+                                    cosFileId: metadata.cosFileId,
+                                    downloadUrl: metadata.download_url,
+                                },
+                                error: null,
+                            }];
+                    case 2:
+                        error_2 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_2;
+                        return [2, {
+                                data: null,
+                                error: error_2 instanceof errors_1.StorageError ? error_2 : new errors_1.StorageError(error_2.message),
+                            }];
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.update = function (path, fileBody, fileOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.upload(path, fileBody, __assign(__assign({}, fileOptions), { upsert: true }))];
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.move = function (fromPath, toPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4, this.copyFile({
+                                fileList: [
+                                    {
+                                        srcPath: this._getCloudPath(fromPath),
+                                        dstPath: this._getCloudPath(toPath),
+                                        overwrite: true,
+                                        removeOriginal: true,
+                                    },
+                                ],
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {
+                            throw new errors_1.StorageError(result.fileList[0].message || 'Move failed');
+                        }
+                        return [2, {
+                                data: { message: "File moved from ".concat(fromPath, " to ").concat(toPath) },
+                                error: null,
+                            }];
+                    case 2:
+                        error_3 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_3;
+                        if ((0, errors_1.isStorageError)(error_3)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_3,
+                                }];
+                        }
+                        throw error_3;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.copy = function (fromPath, toPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4, this.copyFile({
+                                fileList: [
+                                    {
+                                        srcPath: this._getCloudPath(fromPath),
+                                        dstPath: this._getCloudPath(toPath),
+                                        overwrite: true,
+                                        removeOriginal: false,
+                                    },
+                                ],
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {
+                            throw new errors_1.StorageError(result.fileList[0].message || 'Copy failed');
+                        }
+                        return [2, {
+                                data: { path: this._getCloudPath(toPath) },
+                                error: null,
+                            }];
+                    case 2:
+                        error_4 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_4;
+                        if ((0, errors_1.isStorageError)(error_4)) {
+                            return [2, { data: null, error: error_4 }];
+                        }
+                        throw error_4;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.createSignedUrl = function (path, expiresIn, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cloudPath, result, signedUrl, queryParams, transformQuery, separator, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        cloudPath = this._normalizeCloudId(path);
+                        return [4, this.getTempFileURL({
+                                fileList: [
+                                    {
+                                        fileID: cloudPath,
+                                        maxAge: expiresIn,
+                                    },
+                                ],
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        if (result.fileList[0].code !== 'SUCCESS') {
+                            throw new errors_1.StorageError("Failed to create signed URL: [".concat(result.fileList[0].code, "] ").concat(result.fileList[0].fileID));
+                        }
+                        signedUrl = result.fileList[0].download_url;
+                        queryParams = [];
+                        if ((options === null || options === void 0 ? void 0 : options.download) !== undefined) {
+                            if (typeof options.download === 'string') {
+                                queryParams.push("download=".concat(encodeURIComponent(options.download)));
+                            }
+                            else if (options.download === true) {
+                                queryParams.push('download=true');
+                            }
+                        }
+                        if (options === null || options === void 0 ? void 0 : options.transform) {
+                            transformQuery = this._transformOptsToQueryString(options.transform);
+                            if (transformQuery) {
+                                queryParams.push(transformQuery);
+                            }
+                        }
+                        if (queryParams.length > 0) {
+                            separator = signedUrl.includes('?') ? '&' : '?';
+                            signedUrl = "".concat(signedUrl).concat(separator).concat(queryParams.join('&'));
+                        }
+                        return [2, {
+                                data: { signedUrl: signedUrl },
+                                error: null,
+                            }];
+                    case 2:
+                        error_5 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_5;
+                        if ((0, errors_1.isStorageError)(error_5)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_5,
+                                }];
+                        }
+                        throw error_5;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.createSignedUrls = function (paths, expiresIn) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileList, result, error_6;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        fileList = paths.map(function (p) { return ({
+                            fileID: _this._normalizeCloudId(p),
+                            maxAge: expiresIn,
+                        }); });
+                        return [4, this.getTempFileURL({ fileList: fileList })];
+                    case 1:
+                        result = _a.sent();
+                        return [2, {
+                                data: result.fileList.map(function (item, index) { return ({
+                                    path: paths[index],
+                                    signedUrl: item.tempFileURL || '',
+                                    error: item.code === 'SUCCESS' ? null : item.message,
+                                }); }),
+                                error: null,
+                            }];
+                    case 2:
+                        error_6 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_6;
+                        if ((0, errors_1.isStorageError)(error_6)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_6,
+                                }];
+                        }
+                        throw error_6;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.download = function (path, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_7;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        _a = {};
+                        return [4, (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var signedUrlResult, tmpUrl, data;
+                                var _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0: return [4, this.createSignedUrl(path, 600, { transform: options })];
+                                        case 1:
+                                            signedUrlResult = _b.sent();
+                                            if (signedUrlResult.error) {
+                                                throw signedUrlResult.error;
+                                            }
+                                            tmpUrl = encodeURI((_a = signedUrlResult.data) === null || _a === void 0 ? void 0 : _a.signedUrl);
+                                            return [4, this.request.reqClass.get({
+                                                    url: tmpUrl,
+                                                    headers: {},
+                                                    responseType: 'blob',
+                                                })];
+                                        case 2:
+                                            data = (_b.sent()).data;
+                                            if (!data) {
+                                                throw new errors_1.StorageError('Download failed: no file content');
+                                            }
+                                            return [2, new Blob([data])];
+                                    }
+                                });
+                            }); })()];
+                    case 1: return [2, (_a.data = _b.sent(),
+                            _a.error = null,
+                            _a)];
+                    case 2:
+                        error_7 = _b.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_7;
+                        if ((0, errors_1.isStorageError)(error_7)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_7,
+                                }];
+                        }
+                        throw error_7;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.info = function (pathOrFileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isFileId, displayName, bucketId, fileInfo, item, now, lastModified, error_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        isFileId = pathOrFileId.startsWith('cloud://');
+                        displayName = isFileId ? this._extractPathFromFileId(pathOrFileId) : pathOrFileId;
+                        bucketId = isFileId ? this._extractBucketFromFileId(pathOrFileId) : this.bucketId;
+                        return [4, this.getFileInfo({
+                                fileList: [this._normalizeCloudId(pathOrFileId)],
+                            })];
+                    case 1:
+                        fileInfo = _a.sent();
+                        item = fileInfo.fileList[0];
+                        if (item.code !== 'SUCCESS') {
+                            throw new errors_1.StorageError(item.message);
+                        }
+                        now = new Date().toISOString();
+                        lastModified = (item.lastModified ? new Date(item.lastModified) : new Date()).toISOString();
+                        return [2, {
+                                data: {
+                                    id: item.fileID,
+                                    version: '1',
+                                    name: displayName,
+                                    bucketId: bucketId,
+                                    updatedAt: lastModified,
+                                    createdAt: lastModified,
+                                    lastAccessedAt: now,
+                                    size: item.size,
+                                    cacheControl: item.cacheControl,
+                                    contentType: item.contentType,
+                                    etag: item.etag,
+                                    lastModified: lastModified,
+                                    metadata: {},
+                                },
+                                error: null,
+                            }];
+                    case 2:
+                        error_8 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_8;
+                        return [2, {
+                                data: null,
+                                error: error_8 instanceof errors_1.StorageError ? error_8 : new errors_1.StorageError(error_8.message),
+                            }];
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.exists = function (pathOrFileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileInfo, item, error_9;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4, this.getFileInfo({
+                                fileList: [this._normalizeCloudId(pathOrFileId)],
+                            })];
+                    case 1:
+                        fileInfo = _a.sent();
+                        item = fileInfo.fileList[0];
+                        if (item.code === 'FILE_NOT_FOUND') {
+                            return [2, {
+                                    data: false,
+                                    error: null,
+                                }];
+                        }
+                        if (item.code !== 'SUCCESS') {
+                            throw new errors_1.StorageError(item.message);
+                        }
+                        return [2, { data: true, error: null }];
+                    case 2:
+                        error_9 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_9;
+                        throw error_9;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.getPublicUrl = function (path, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.createSignedUrl(path, 600, options)];
+                    case 1:
+                        res = _a.sent();
+                        if (res.data) {
+                            return [2, {
+                                    data: { publicUrl: res.data.signedUrl },
+                                }];
+                        }
+                        return [2, { data: null, error: res.error }];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.remove = function (paths) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chunkSize_1, pathChunks, i, fileInfoResults, fileInfoMap_1, fileList, result, failedFiles, now_1, error_10;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        chunkSize_1 = 10;
+                        pathChunks = [];
+                        for (i = 0; i < paths.length; i += chunkSize_1) {
+                            pathChunks.push(paths.slice(i, i + chunkSize_1));
+                        }
+                        return [4, Promise.all(pathChunks.map(function (chunk) { return Promise.all(chunk.map(function (path) { return _this.info(path); })); }))];
+                    case 1:
+                        fileInfoResults = _a.sent();
+                        fileInfoMap_1 = new Map();
+                        fileInfoResults.flat().forEach(function (result, index) {
+                            if (result.data) {
+                                fileInfoMap_1.set(paths[Math.floor(index / chunkSize_1) * chunkSize_1 + (index % chunkSize_1)], result.data);
+                            }
+                        });
+                        fileList = paths.map(function (p) { return _this._normalizeCloudId(p); });
+                        return [4, this.deleteFile({ fileList: fileList })];
+                    case 2:
+                        result = _a.sent();
+                        failedFiles = result.fileList.filter(function (item) { return item.code !== 'SUCCESS'; });
+                        if (failedFiles.length > 0) {
+                            throw new errors_1.StorageError("Delete failed for ".concat(failedFiles.length, " file(s)"));
+                        }
+                        now_1 = new Date().toISOString();
+                        return [2, {
+                                data: paths.map(function (p) {
+                                    var info = fileInfoMap_1.get(p);
+                                    return {
+                                        name: info === null || info === void 0 ? void 0 : info.name,
+                                        id: info === null || info === void 0 ? void 0 : info.id,
+                                        bucket_id: info === null || info === void 0 ? void 0 : info.bucketId,
+                                        owner: undefined,
+                                        updated_at: (info === null || info === void 0 ? void 0 : info.updatedAt) || now_1,
+                                        created_at: info === null || info === void 0 ? void 0 : info.createdAt,
+                                        last_accessed_at: (info === null || info === void 0 ? void 0 : info.lastAccessedAt) || now_1,
+                                        metadata: (info === null || info === void 0 ? void 0 : info.metadata) || {},
+                                        buckets: {
+                                            id: info === null || info === void 0 ? void 0 : info.bucketId,
+                                            name: info === null || info === void 0 ? void 0 : info.bucketId,
+                                            owner: undefined,
+                                            public: false,
+                                            created_at: '',
+                                            updated_at: now_1,
+                                        },
+                                    };
+                                }),
+                                error: null,
+                            }];
+                    case 3:
+                        error_10 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_10;
+                        if ((0, errors_1.isStorageError)(error_10)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_10,
+                                }];
+                        }
+                        throw error_10;
+                    case 4: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.list = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new errors_1.StorageError('Not implemented');
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype._getCloudPath = function (path) {
+        var cleanPath = path.replace(/^\/|\/$/g, '').replace(/\/+/g, '/');
+        return cleanPath;
+    };
+    SupabaseFileAPILikeStorage.prototype._normalizeCloudId = function (path) {
+        var _a;
+        if (/^cloud:\/\//.test(path)) {
+            return path;
+        }
+        var cleanPath = this._getCloudPath(path);
+        if (this.bucketId) {
+            var envId = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.env) || '';
+            if (envId) {
+                return "cloud://".concat(envId, ".").concat(this.bucketId, "/").concat(cleanPath);
+            }
+        }
+        else {
+            throw new errors_1.StorageError('bucketId is not set');
+        }
+    };
+    SupabaseFileAPILikeStorage.prototype.toBase64 = function (data) {
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(data).toString('base64');
+        }
+        return btoa(data);
+    };
+    SupabaseFileAPILikeStorage.prototype._transformOptsToQueryString = function (transform) {
+        var params = ['imageMogr2'];
+        if (transform.width || transform.height) {
+            var width = transform.width || '';
+            var height = transform.height || '';
+            if (transform.resize === 'fill') {
+                params.push("thumbnail/".concat(width, "x").concat(height, "!"));
+            }
+            else if (transform.resize === 'contain') {
+                params.push("thumbnail/".concat(width, "x").concat(height));
+            }
+            else {
+                params.push("thumbnail/".concat(width, "x").concat(height, "^"));
+            }
+        }
+        if (transform.format && transform.format !== 'origin') {
+            params.push("format/".concat(transform.format));
+        }
+        if (transform.quality !== undefined) {
+            var quality = Math.max(1, Math.min(100, transform.quality));
+            params.push("quality/".concat(quality));
+        }
+        return params.join('/');
+    };
+    SupabaseFileAPILikeStorage.prototype._extractPathFromFileId = function (fileId) {
+        var withoutProtocol = fileId.replace(/^cloud:\/\//, '');
+        var parts = withoutProtocol.split('/');
+        if (parts.length < 2) {
+            return fileId;
+        }
+        return parts.slice(1).join('/');
+    };
+    SupabaseFileAPILikeStorage.prototype._extractBucketFromFileId = function (fileId) {
+        var withoutProtocol = fileId.replace(/^cloud:\/\//, '');
+        var parts = withoutProtocol.split('/');
+        if (parts.length < 1) {
+            return '';
+        }
+        var envAndBucket = parts[0];
+        var dotIndex = envAndBucket.indexOf('.');
+        if (dotIndex === -1) {
+            return envAndBucket;
+        }
+        return envAndBucket.substring(dotIndex + 1);
+    };
+    return SupabaseFileAPILikeStorage;
+}(storage_1.CloudbaseStorage));
+exports.SupabaseFileAPILikeStorage = SupabaseFileAPILikeStorage;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/supabase/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { constants } from '@cloudbase/utilities'\n\nimport { CloudbaseStorage, COMPONENT_NAME } from '../storage'\n\nimport { Camelize, FileBody, FileObject, FileObjectV2, FileOptions, TransformOptions } from './types'\nimport { isStorageError, StorageError } from './errors'\n\nconst { ERRORS } = constants\n\nexport class SupabaseFileAPILikeStorage extends CloudbaseStorage {\n  private shouldThrowOnError = false\n  private bucketId = ''\n\n  throwOnError(): this {\n    this.shouldThrowOnError = true\n    return this\n  }\n\n  from(bucket?: string) {\n    this.bucketId = bucket || ''\n    return this\n  }\n\n  async upload(\n    path: string,\n    fileBody: FileBody,\n    fileOptions?: FileOptions,\n  ): Promise<\n    { data: { id: string; path: string; fullPath: string }; error: null } | { data: null; error: StorageError }\n    > {\n    const options = { upsert: true, ...fileOptions }\n    const { cacheControl, contentType, metadata } = options\n    try {\n      const cloudPath = this._getCloudPath(path)\n      const uploadFileParams: Parameters<CloudbaseStorage['uploadFile']>[0] = {\n        cloudPath,\n        filePath: fileBody as any,\n      }\n\n      if (cacheControl || contentType || metadata) {\n        const headers = {}\n        if (cacheControl) {\n          headers['cache-control'] = cacheControl\n        }\n        if (contentType) {\n          headers['content-type'] = contentType\n        }\n\n        if (metadata) {\n          headers['x-cos-metadata-metadata'] = this.toBase64(JSON.stringify(metadata))\n        }\n\n        uploadFileParams.headers = headers\n      }\n\n      const result = await this.uploadFile(uploadFileParams)\n\n      // IUploadFileRes 没有 code 字段，如果没有 fileID 则表示失败\n      if (!result.fileID) {\n        throw new Error(JSON.stringify({\n          code: ERRORS.OPERATION_FAIL,\n          msg: `[${COMPONENT_NAME}.update] no fileID returned`,\n        }),)\n      }\n\n      return {\n        data: {\n          id: result.fileID,\n          path,\n          fullPath: path,\n        },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async uploadToSignedUrl(\n    path: string,\n    _token: string,\n    fileBody: FileBody,\n    fileOptions?: FileOptions,\n  ): Promise<\n    { data: { id: string; path: string; fullPath: string }; error: null } | { data: null; error: StorageError }\n    > {\n    return this.upload(path, fileBody, fileOptions)\n  }\n\n  async createSignedUploadUrl(path: string): Promise<\n  | {\n    data: {\n      signedUrl: string\n      token: string\n      path: string\n      // CloudBase 额外的元数据字段\n      authorization?: string\n      id?: string\n      cosFileId?: string\n      downloadUrl?: string\n    }\n    error: null\n  }\n  | { data: null; error: StorageError }\n  > {\n    try {\n      const cloudPath = this._getCloudPath(path)\n\n      const { data: metadata } = await this.getUploadMetadata({ cloudPath })\n\n      return {\n        data: {\n          signedUrl: metadata.url,\n          token: metadata.token,\n          path,\n          // 返回 CloudBase 的额外元数据，供 uploadToSignedUrl 使用\n          authorization: metadata.authorization,\n          id: metadata.fileId,\n          cosFileId: metadata.cosFileId,\n          downloadUrl: metadata.download_url,\n        },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      return {\n        data: null,\n        error: error instanceof StorageError ? error : new StorageError(error.message),\n      }\n    }\n  }\n\n  async update(\n    path: string,\n    fileBody: FileBody,\n    fileOptions?: FileOptions,\n  ): Promise<\n    { data: { id: string; path: string; fullPath: string }; error: null } | { data: null; error: StorageError }\n    > {\n    return this.upload(path, fileBody, { ...fileOptions, upsert: true })\n  }\n\n  async move(\n    fromPath: string,\n    toPath: string,\n    // options?: DestinationOptions,\n  ): Promise<{ data: { message: string }; error: null } | { data: null; error: StorageError }> {\n    try {\n      const result = await this.copyFile({\n        fileList: [\n          {\n            srcPath: this._getCloudPath(fromPath),\n            dstPath: this._getCloudPath(toPath),\n            overwrite: true,\n            removeOriginal: true,\n          },\n        ],\n      })\n\n      if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {\n        throw new StorageError(result.fileList[0].message || 'Move failed')\n      }\n\n      return {\n        data: { message: `File moved from ${fromPath} to ${toPath}` },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async copy(\n    fromPath: string,\n    toPath: string,\n    // options?: DestinationOptions,\n  ): Promise<{ data: { path: string }; error: null } | { data: null; error: StorageError }> {\n    try {\n      const result = await this.copyFile({\n        fileList: [\n          {\n            srcPath: this._getCloudPath(fromPath),\n            dstPath: this._getCloudPath(toPath),\n            overwrite: true,\n            removeOriginal: false,\n          },\n        ],\n      })\n\n      if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {\n        throw new StorageError(result.fileList[0].message || 'Copy failed')\n      }\n\n      return {\n        data: { path: this._getCloudPath(toPath) },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return { data: null, error }\n      }\n      throw error\n    }\n  }\n\n  async createSignedUrl(\n    path: string,\n    expiresIn: number,\n    options?: {\n      download?: string | boolean\n      transform?: TransformOptions\n    },\n  ): Promise<{ data: { signedUrl: string }; error: null } | { data: null; error: StorageError }> {\n    try {\n      const cloudPath = this._normalizeCloudId(path)\n      const result = await this.getTempFileURL({\n        fileList: [\n          {\n            fileID: cloudPath,\n            maxAge: expiresIn,\n          },\n        ],\n      })\n\n      // IGetFileUrlItem 有 code 字段但没有 message 字段\n      if (result.fileList[0].code !== 'SUCCESS') {\n        throw new StorageError(`Failed to create signed URL: [${result.fileList[0].code}] ${result.fileList[0].fileID}`)\n      }\n\n      let signedUrl = result.fileList[0].download_url\n\n      // 构建查询参数\n      const queryParams: string[] = []\n\n      // 如果有 download 参数，添加到 URL 中\n      if (options?.download !== undefined) {\n        if (typeof options.download === 'string') {\n          // download 是文件名\n          queryParams.push(`download=${encodeURIComponent(options.download)}`)\n        } else if (options.download === true) {\n          // download 是 true，使用原文件名或默认值\n          queryParams.push('download=true')\n        }\n      }\n\n      // 如果有图片转换参数，添加到 URL 中\n      if (options?.transform) {\n        const transformQuery = this._transformOptsToQueryString(options.transform)\n        if (transformQuery) {\n          queryParams.push(transformQuery)\n        }\n      }\n\n      // 拼接所有查询参数\n      if (queryParams.length > 0) {\n        const separator = signedUrl.includes('?') ? '&' : '?'\n        signedUrl = `${signedUrl}${separator}${queryParams.join('&')}`\n      }\n\n      return {\n        data: { signedUrl },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async createSignedUrls(\n    paths: string[],\n    expiresIn: number,\n    // options?: {\n    //   download?: string | boolean\n    // },\n  ): Promise<\n    | { data: Array<{ path: string; signedUrl: string; error: string | null }>; error: null }\n    | { data: null; error: StorageError }\n    > {\n    try {\n      const fileList = paths.map(p => ({\n        fileID: this._normalizeCloudId(p),\n        maxAge: expiresIn,\n      }))\n\n      const result = await this.getTempFileURL({ fileList })\n\n      return {\n        data: result.fileList.map((item: any, index: number) => ({\n          path: paths[index],\n          signedUrl: item.tempFileURL || '',\n          error: item.code === 'SUCCESS' ? null : item.message,\n        })),\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async download(\n    path: string,\n    options?: TransformOptions,\n  ): Promise<{\n      data: Blob\n      error: StorageError | null\n    }> {\n    try {\n      return {\n        data: await (async () => {\n          const signedUrlResult = await this.createSignedUrl(path, 600, { transform: options })\n          if (signedUrlResult.error) {\n            throw signedUrlResult.error\n          }\n          const tmpUrl = encodeURI(signedUrlResult.data?.signedUrl)\n\n          const { data } = await (this as any).request.reqClass.get({\n            url: tmpUrl,\n            headers: {}, // 下载资源请求不经过service，header清空\n            responseType: 'blob',\n          })\n\n          if (!data) {\n            throw new StorageError('Download failed: no file content')\n          }\n\n          // 将 Buffer 转换为 Uint8Array 以兼容 Blob\n          return new Blob([data])\n        })(),\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  /**\n   * 获取文件信息\n   *\n   * @param pathOrFileId - 相对路径（如 'images/photo.jpg'）或 CloudBase fileID（以 'cloud://' 开头）\n   * @returns 文件信息对象\n   *\n   * @example\n   * ```typescript\n   * // 使用相对路径\n   * const { data } = await bucket.info('images/photo.jpg')\n   *\n   * // 使用 CloudBase fileID\n   * const { data } = await bucket.info('cloud://env-id.xxxx-xxxx/images/photo.jpg')\n   * ```\n   */\n  async info(pathOrFileId: string,): Promise<{ data: Camelize<FileObjectV2>; error: null } | { data: null; error: StorageError }> {\n    try {\n      // 判断是 fileID 还是相对路径\n      const isFileId = pathOrFileId.startsWith('cloud://')\n      const displayName = isFileId ? this._extractPathFromFileId(pathOrFileId) : pathOrFileId\n      const bucketId = isFileId ? this._extractBucketFromFileId(pathOrFileId) : this.bucketId\n\n      const fileInfo = await this.getFileInfo({\n        fileList: [this._normalizeCloudId(pathOrFileId)],\n      })\n\n      const item = fileInfo.fileList[0]\n\n      if (item.code !== 'SUCCESS') {\n        throw new StorageError(item.message)\n      }\n\n      const now = new Date().toISOString()\n      const lastModified = (item.lastModified ? new Date(item.lastModified) : new Date()).toISOString()\n      return {\n        data: {\n          id: item.fileID,\n          version: '1',\n          name: displayName,\n          bucketId,\n          updatedAt: lastModified,\n          createdAt: lastModified,\n          lastAccessedAt: now,\n          size: item.size,\n          cacheControl: item.cacheControl,\n          contentType: item.contentType,\n          etag: item.etag,\n          lastModified,\n          metadata: {},\n        },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      return {\n        data: null,\n        error: error instanceof StorageError ? error : new StorageError(error.message),\n      }\n    }\n  }\n\n  async exists(pathOrFileId: string): Promise<{ data: boolean; error: null } | { data: null; error: StorageError }> {\n    try {\n      // 判断是 fileID 还是相对路径\n      const fileInfo = await this.getFileInfo({\n        fileList: [this._normalizeCloudId(pathOrFileId)],\n      })\n\n      const item = fileInfo.fileList[0]\n\n      if (item.code === 'FILE_NOT_FOUND') {\n        return {\n          data: false,\n          error: null,\n        }\n      }\n\n      if (item.code !== 'SUCCESS') {\n        throw new StorageError(item.message)\n      }\n\n      return { data: true, error: null }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      throw error\n    }\n  }\n\n  async getPublicUrl(\n    path: string,\n    options?: {\n      download?: string | boolean\n      transform?: TransformOptions\n    },\n  ): Promise<\n    | {\n      data: { publicUrl: string }\n    }\n    | { data: null; error: StorageError }\n    > {\n    const res = await this.createSignedUrl(path, 600, options)\n\n    if (res.data) {\n      return {\n        data: { publicUrl: res.data.signedUrl },\n      }\n    }\n\n    return { data: null, error: res.error as StorageError }\n  }\n\n  async remove(paths: string[]): Promise<{ data: FileObject[]; error: null } | { data: null; error: StorageError }> {\n    try {\n      // 分组获取文件信息，每组最多10个\n      const chunkSize = 10\n      const pathChunks: string[][] = []\n      for (let i = 0; i < paths.length; i += chunkSize) {\n        pathChunks.push(paths.slice(i, i + chunkSize))\n      }\n\n      // 并行获取所有分组的文件信息\n      const fileInfoResults = await Promise.all(pathChunks.map(chunk => Promise.all(chunk.map(path => this.info(path)))),)\n\n      // 合并所有文件信息并构建映射表（path -> fileInfo）\n      const fileInfoMap = new Map<string, Camelize<FileObjectV2>>()\n      fileInfoResults.flat().forEach((result, index) => {\n        if (result.data) {\n          fileInfoMap.set(paths[Math.floor(index / chunkSize) * chunkSize + (index % chunkSize)], result.data)\n        }\n      })\n\n      // 执行删除操作\n      const fileList = paths.map(p => this._normalizeCloudId(p))\n      const result = await this.deleteFile({ fileList })\n\n      // IDeleteFileRes 的 fileList 数组中每个项有 code 字段\n      const failedFiles = result.fileList.filter(item => item.code !== 'SUCCESS')\n      if (failedFiles.length > 0) {\n        throw new StorageError(`Delete failed for ${failedFiles.length} file(s)`)\n      }\n\n      const now = new Date().toISOString()\n\n      // 使用获取到的文件信息构建返回数据\n      return {\n        data: paths.map((p) => {\n          const info = fileInfoMap.get(p)\n\n          return {\n            name: info?.name,\n            id: info?.id,\n            bucket_id: info?.bucketId,\n            owner: undefined, // 无法计算owner\n            updated_at: info?.updatedAt || now,\n            created_at: info?.createdAt,\n            last_accessed_at: info?.lastAccessedAt || now,\n            metadata: info?.metadata || {},\n            /**\n             * TODO: 获取补全 Bucket 信息\n             */\n            buckets: {\n              id: info?.bucketId,\n              name: info?.bucketId,\n              owner: undefined, // 无法计算owner\n              public: false, // 未知\n              created_at: '', // 未知\n              updated_at: now, // 未知\n            },\n          }\n        }),\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async list() {\n    throw new StorageError('Not implemented')\n  }\n\n  private _getCloudPath(path: string): string {\n    // 清理路径：移除首尾斜杠，合并多个斜杠\n    const cleanPath = path.replace(/^\\/|\\/$/g, '').replace(/\\/+/g, '/')\n\n    // 否则返回清理后的相对路径\n    return cleanPath\n  }\n\n  private _normalizeCloudId(path: string) {\n    // 如果已经是 cloud:// 格式，直接返回\n    if (/^cloud:\\/\\//.test(path)) {\n      return path\n    }\n    const cleanPath = this._getCloudPath(path)\n\n    // 如果设置了 bucketId，构建完整的 cloud:// 路径\n    if (this.bucketId) {\n      // 获取环境 ID\n      const envId = this.config?.env || ''\n      if (envId) {\n        return `cloud://${envId}.${this.bucketId}/${cleanPath}`\n      }\n    } else {\n      throw new StorageError('bucketId is not set')\n    }\n  }\n\n  private toBase64(data: string) {\n    if (typeof Buffer !== 'undefined') {\n      return Buffer.from(data).toString('base64')\n    }\n    return btoa(data)\n  }\n\n  /**\n   * 将 TransformOptions 转换为腾讯云数据万象的 imageMogr2 查询字符串\n   *\n   * 腾讯云数据万象使用 imageMogr2 接口进行图片处理，支持以下参数：\n   * - /thumbnail/<Width>x<Height> - 缩放\n   * - /format/<Format> - 格式转换\n   * - /quality/<Quality> - 质量调整\n   * - /rquality/<Quality> - 相对质量\n   *\n   * @param transform - Supabase TransformOptions\n   * @returns 腾讯云数据万象的查询字符串\n   *\n   * @example\n   * ```typescript\n   * _transformOptsToQueryString({ width: 300, height: 200, quality: 80, format: 'origin' })\n   * // 返回: 'imageMogr2/thumbnail/300x200/quality/80'\n   * ```\n   */\n  private _transformOptsToQueryString(transform: TransformOptions): string {\n    const params: string[] = ['imageMogr2']\n\n    // 处理缩放参数\n    if (transform.width || transform.height) {\n      const width = transform.width || ''\n      const height = transform.height || ''\n\n      // 根据 resize 模式选择不同的缩放方式\n      if (transform.resize === 'fill') {\n        // fill: 强制缩放到指定尺寸，可能变形\n        params.push(`thumbnail/${width}x${height}!`)\n      } else if (transform.resize === 'contain') {\n        // contain: 等比缩放，完整显示在指定尺寸内\n        params.push(`thumbnail/${width}x${height}`)\n      } else {\n        // cover (默认): 等比缩放，填充指定尺寸，可能裁剪\n        // 使用 /thumbnail/<Width>x<Height>^ 表示填充模式\n        params.push(`thumbnail/${width}x${height}^`)\n      }\n    }\n\n    // 处理格式转换\n    // format: 'origin' 表示保持原格式，不传此参数\n    if (transform.format && transform.format !== 'origin') {\n      params.push(`format/${transform.format}`)\n    }\n\n    // 处理质量参数\n    if (transform.quality !== undefined) {\n      // 腾讯云数据万象的 quality 参数范围是 1-100\n      const quality = Math.max(1, Math.min(100, transform.quality))\n      params.push(`quality/${quality}`)\n    }\n\n    return params.join('/')\n  }\n\n  /**\n   * 从 CloudBase fileID 中提取文件路径\n   *\n   * @param fileId - CloudBase fileID (格式: cloud://env-id.bucket/path/to/file.jpg)\n   * @returns 提取的文件路径\n   *\n   * @example\n   * ```typescript\n   * _extractPathFromFileId('cloud://test-env.test-bucket/images/photo.jpg')\n   * // 返回: 'images/photo.jpg'\n   *\n   * _extractPathFromFileId('cloud://test-env.test-bucket/file.txt')\n   * // 返回: 'file.txt'\n   * ```\n   */\n  private _extractPathFromFileId(fileId: string): string {\n    // fileID 格式: cloud://env-id.bucket/path/to/file.jpg\n    // 需要提取第一个 / 后面的所有内容（包括 bucket 和路径）\n    // 然后再提取 bucket 后面的路径部分\n\n    // 移除 cloud:// 前缀\n    const withoutProtocol = fileId.replace(/^cloud:\\/\\//, '')\n\n    // 分割为 [env-id.bucket, path, to, file.jpg]\n    const parts = withoutProtocol.split('/')\n\n    if (parts.length < 2) {\n      // 如果无法解析，返回完整的 fileID\n      return fileId\n    }\n\n    // 移除第一部分（env-id.bucket），返回剩余路径\n    return parts.slice(1).join('/')\n  }\n\n  /**\n   * 从 CloudBase fileID 中提取 bucket 名称\n   *\n   * @param fileId - CloudBase fileID (格式: cloud://env-id.bucket/path/to/file.jpg)\n   * @returns 提取的 bucket 名称\n   *\n   * @example\n   * ```typescript\n   * _extractBucketFromFileId('cloud://test-env.test-bucket/images/photo.jpg')\n   * // 返回: 'test-bucket'\n   *\n   * _extractBucketFromFileId('cloud://prod-env.my-bucket/file.txt')\n   * // 返回: 'my-bucket'\n   * ```\n   */\n  private _extractBucketFromFileId(fileId: string): string {\n    // fileID 格式: cloud://env-id.bucket/path/to/file.jpg\n    // 需要提取 env-id.bucket 中的 bucket 部分\n\n    // 移除 cloud:// 前缀\n    const withoutProtocol = fileId.replace(/^cloud:\\/\\//, '')\n\n    // 分割为 [env-id.bucket, path, to, file.jpg]\n    const parts = withoutProtocol.split('/')\n\n    if (parts.length < 1) {\n      // 如果无法解析，返回默认 bucket\n      return ''\n    }\n\n    // 第一部分是 env-id.bucket，提取 bucket 部分\n    // 格式: env-id.bucket 或 env-id.bucket-name\n    const envAndBucket = parts[0]\n\n    // 查找第一个点的位置\n    const dotIndex = envAndBucket.indexOf('.')\n\n    if (dotIndex === -1) {\n      // 如果没有点，返回整个字符串\n      return envAndBucket\n    }\n\n    // 返回点后面的部分（bucket 名称）\n    return envAndBucket.substring(dotIndex + 1)\n  }\n}\n"]}