flydrive
Version:
File storage library with unified API to manage files across multiple cloud storage providers like S3, GCS, R2 and so on
173 lines (172 loc) • 6.58 kB
JavaScript
import "node:module";
import { createError } from "@poppinss/utils/exception";
import { basename } from "node:path";
import { normalize } from "node:path/posix";
import string from "@poppinss/utils/string";
var __defProp = Object.defineProperty;
var __exportAll = (all, no_symbols) => {
let target = {};
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: true
});
if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
return target;
};
var errors_exports = /* @__PURE__ */ __exportAll({
E_CANNOT_CHECK_FILE_EXISTENCE: () => E_CANNOT_CHECK_FILE_EXISTENCE,
E_CANNOT_COPY_FILE: () => E_CANNOT_COPY_FILE,
E_CANNOT_DELETE_DIRECTORY: () => E_CANNOT_DELETE_DIRECTORY,
E_CANNOT_DELETE_FILE: () => E_CANNOT_DELETE_FILE,
E_CANNOT_GENERATE_URL: () => E_CANNOT_GENERATE_URL,
E_CANNOT_GET_METADATA: () => E_CANNOT_GET_METADATA,
E_CANNOT_MOVE_FILE: () => E_CANNOT_MOVE_FILE,
E_CANNOT_READ_FILE: () => E_CANNOT_READ_FILE,
E_CANNOT_SET_VISIBILITY: () => E_CANNOT_SET_VISIBILITY,
E_CANNOT_WRITE_FILE: () => E_CANNOT_WRITE_FILE,
E_INVALID_KEY: () => E_INVALID_KEY,
E_PATH_TRAVERSAL_DETECTED: () => E_PATH_TRAVERSAL_DETECTED,
E_UNALLOWED_CHARACTERS: () => E_UNALLOWED_CHARACTERS
});
const E_CANNOT_WRITE_FILE = createError("Cannot write file at location \"%s\"", "E_CANNOT_WRITE_FILE");
const E_CANNOT_READ_FILE = createError("Cannot read file from location \"%s\"", "E_CANNOT_READ_FILE");
const E_CANNOT_DELETE_FILE = createError("Cannot delete file at location \"%s\"", "E_CANNOT_DELETE_FILE");
const E_CANNOT_DELETE_DIRECTORY = createError("Cannot delete directory at location \"%s\"", "E_CANNOT_DELETE_DIRECTORY");
const E_CANNOT_COPY_FILE = createError("Cannot copy file from \"%s\" to \"%s\"", "E_CANNOT_COPY_FILE");
const E_CANNOT_MOVE_FILE = createError("Cannot move file from \"%s\" to \"%s\"", "E_CANNOT_MOVE_FILE");
const E_CANNOT_CHECK_FILE_EXISTENCE = createError("Unable to check existence for file at location \"%s\"", "E_CANNOT_CHECK_FILE_EXISTENCE");
const E_CANNOT_GET_METADATA = createError("Unable to retrieve metadata of file at location \"%s\"", "E_CANNOT_GET_METADATA");
const E_CANNOT_SET_VISIBILITY = createError("Unable to set visibility for file at location \"%s\"", "E_CANNOT_SET_VISIBILITY");
const E_CANNOT_GENERATE_URL = createError("Cannot generate URL for file at location \"%s\"", "E_CANNOT_GENERATE_URL");
const E_UNALLOWED_CHARACTERS = createError("The key \"%s\" has unallowed characters", "E_UNALLOWED_CHARACTERS");
const E_INVALID_KEY = createError("Invalid key \"%s\". After normalization results in an empty string", "E_INVALID_KEY");
const E_PATH_TRAVERSAL_DETECTED = createError("Path traversal segment detected in key \"%s\"", "E_PATH_TRAVERSAL_DETECTED");
var KeyNormalizer = class KeyNormalizer {
static allowedCharacterSet = /^[A-Za-z0-9-_!\/\.\s]*$/;
#preNormalize(key) {
let normalizedKey = string.condenseWhitespace(key);
return string.toUnixSlash(normalizedKey).replace(/\/{2,}/g, "/").replace(/\.{3,}\//g, "../");
}
#validateCharacterSet(key, originalKey) {
if (!KeyNormalizer.allowedCharacterSet.test(key)) throw new E_UNALLOWED_CHARACTERS([originalKey]);
}
#checkForPathTraversal(key, originalKey) {
const tokens = key.split("/");
for (let token of tokens) if (token === "..") throw new E_PATH_TRAVERSAL_DETECTED([originalKey]);
}
#postNormalize(key) {
return normalize(key).replace(/^\/|\/$/g, "").replace(/^\.|\.$/g, "");
}
normalize(key) {
let normalizedKey = this.#preNormalize(key);
this.#validateCharacterSet(normalizedKey, key);
this.#checkForPathTraversal(normalizedKey, key);
normalizedKey = this.#postNormalize(normalizedKey);
if (normalizedKey.trim() === "") throw new E_INVALID_KEY([key]);
return normalizedKey;
}
};
var DriveFile = class {
#driver;
#metaData;
#normalizer = new KeyNormalizer();
key;
name;
isFile = true;
isDirectory = false;
constructor(key, driver, metaData) {
this.#driver = driver;
this.#metaData = metaData;
this.key = this.#normalizer.normalize(key);
this.name = basename(this.key);
}
async exists() {
try {
return await this.#driver.exists(this.key);
} catch (error) {
throw new E_CANNOT_CHECK_FILE_EXISTENCE([this.key], { cause: error });
}
}
async get() {
try {
return await this.#driver.get(this.key);
} catch (error) {
throw new E_CANNOT_READ_FILE([this.key], { cause: error });
}
}
async getStream() {
try {
return await this.#driver.getStream(this.key);
} catch (error) {
throw new E_CANNOT_READ_FILE([this.key], { cause: error });
}
}
async getBytes() {
try {
return await this.#driver.getBytes(this.key);
} catch (error) {
throw new E_CANNOT_READ_FILE([this.key], { cause: error });
}
}
async getArrayBuffer() {
process.emitWarning("getArrayBuffer() method has been deprecated. Instead use \"getBytes\"", "DeprecationWarning");
return this.getBytes();
}
async getMetaData() {
if (this.#metaData) return this.#metaData;
try {
return await this.#driver.getMetaData(this.key);
} catch (error) {
throw new E_CANNOT_GET_METADATA([this.key], { cause: error });
}
}
async getVisibility() {
try {
return await this.#driver.getVisibility(this.key);
} catch (error) {
throw new E_CANNOT_GET_METADATA([this.key], { cause: error });
}
}
async getUrl() {
try {
return await this.#driver.getUrl(this.key);
} catch (error) {
throw new E_CANNOT_GENERATE_URL([this.key], { cause: error });
}
}
async getSignedUrl(options) {
try {
return await this.#driver.getSignedUrl(this.key, options);
} catch (error) {
throw new E_CANNOT_GENERATE_URL([this.key], { cause: error });
}
}
async getSignedUploadUrl(options) {
try {
return await this.#driver.getSignedUploadUrl(this.key, options);
} catch (error) {
throw new E_CANNOT_GENERATE_URL([this.key], { cause: error });
}
}
async toSnapshot() {
const metaData = await this.getMetaData();
return {
key: this.key,
name: this.name,
contentLength: metaData.contentLength,
lastModified: metaData.lastModified.toString(),
etag: metaData.etag,
contentType: metaData.contentType
};
}
};
var DriveDirectory = class {
isFile = false;
isDirectory = true;
name;
constructor(prefix) {
this.prefix = prefix;
this.name = basename(this.prefix);
}
};
export { E_CANNOT_DELETE_DIRECTORY as a, E_CANNOT_SET_VISIBILITY as c, E_CANNOT_COPY_FILE as i, E_CANNOT_WRITE_FILE as l, DriveFile as n, E_CANNOT_DELETE_FILE as o, KeyNormalizer as r, E_CANNOT_MOVE_FILE as s, DriveDirectory as t, errors_exports as u };