@visulima/storage 1.0.0-alpha.9 → 1.0.0

package/dist/packem_shared/ERRORS-D0apMqnc.js

@@ -1,97 +0,0 @@
-var ERRORS = /* @__PURE__ */ ((ERRORS2) => {
-  ERRORS2["BAD_REQUEST"] = "BadRequest";
-  ERRORS2["CHECKSUM_MISMATCH"] = "ChecksumMismatch";
-  ERRORS2["FILE_CONFLICT"] = "FileConflict";
-  ERRORS2["FILE_ERROR"] = "FileError";
-  ERRORS2["FILE_LOCKED"] = "FileLocked";
-  ERRORS2["FILE_NOT_ALLOWED"] = "FileNotAllowed";
-  ERRORS2["FILE_NOT_FOUND"] = "FileNotFound";
-  ERRORS2["FORBIDDEN"] = "Forbidden";
-  ERRORS2["GONE"] = "Gone";
-  ERRORS2["INVALID_FILE_NAME"] = "InvalidFileName";
-  ERRORS2["INVALID_FILE_SIZE"] = "InvalidFileSize";
-  ERRORS2["INVALID_RANGE"] = "InvalidRange";
-  ERRORS2["INVALID_TYPE"] = "Invalidtype";
-  ERRORS2["METHOD_NOT_ALLOWED"] = "MethodNotAllowed";
-  ERRORS2["REQUEST_ABORTED"] = "RequestAborted";
-  ERRORS2["REQUEST_ENTITY_TOO_LARGE"] = "RequestEntityTooLarge";
-  ERRORS2["STORAGE_BUSY"] = "StorageBusy";
-  ERRORS2["STORAGE_ERROR"] = "StorageError";
-  ERRORS2["TOO_MANY_REQUESTS"] = "TooManyRequests";
-  ERRORS2["UNKNOWN_ERROR"] = "UnknownError";
-  ERRORS2["UNPROCESSABLE_ENTITY"] = "UnprocessableEntity";
-  ERRORS2["UNSUPPORTED_CHECKSUM_ALGORITHM"] = "UnsupportedChecksumAlgorithm";
-  ERRORS2["UNSUPPORTED_MEDIA_TYPE"] = "UnsupportedMediaType";
-  return ERRORS2;
-})(ERRORS || {});
-const ErrorMap = (() => {
-  const errors = {
-    BadRequest: [400, "Bad request"],
-    ChecksumMismatch: [460, "Checksum mismatch"],
-    FileConflict: [409, "File conflict"],
-    FileError: [500, "Something went wrong writing the file"],
-    FileLocked: [423, "File locked"],
-    FileNotAllowed: [403, "File not allowed"],
-    FileNotFound: [404, "Not found"],
-    Forbidden: [403, "Authenticated user is not allowed access"],
-    Gone: [410, "The file for this url no longer exists"],
-    InvalidFileName: [400, "Invalid file name or it cannot be retrieved"],
-    InvalidFileSize: [400, "File size cannot be retrieved"],
-    InvalidRange: [400, "Invalid or missing content-range header"],
-    Invalidtype: [400, 'Invalid or missing "content-type" header'],
-    MethodNotAllowed: [405, "Method not allowed"],
-    RequestAborted: [499, "Request aborted"],
-    RequestEntityTooLarge: [413, "Request entity too large"],
-    StorageBusy: [503, "Storage is busy"],
-    StorageError: [503, "Storage error"],
-    TooManyRequests: [429, "Too many requests"],
-    UnknownError: [500, "Something went wrong"],
-    UnprocessableEntity: [422, "Validation failed"],
-    UnsupportedChecksumAlgorithm: [400, "Unsupported checksum algorithm"],
-    UnsupportedMediaType: [415, "Unsupported media type"]
-  };
-  const errorMap = {};
-  Object.keys(errors).forEach((code) => {
-    const [statusCode, message] = errors[code];
-    errorMap[code] = { code, message, statusCode };
-  });
-  return errorMap;
-})();
-class UploadError extends Error {
-  name = "UploadError";
-  /** The standardized error code from the ERRORS enum */
-  UploadErrorCode = "UnknownError" /* UNKNOWN_ERROR */;
-  /** Optional additional error details */
-  detail;
-  /**
-   * Creates a new UploadError instance.
-   * @param code Standardized error code (defaults to UNKNOWN_ERROR)
-   * @param message Human-readable error message (defaults to the code)
-   * @param detail Optional additional error details
-   */
-  constructor(code = "UnknownError" /* UNKNOWN_ERROR */, message, detail) {
-    super(message || code);
-    this.name = "UploadError";
-    this.detail = detail;
-    if (Object.values(ERRORS).includes(code)) {
-      this.UploadErrorCode = code;
-    }
-  }
-}
-const isUploadError = (error) => !!error.UploadErrorCode;
-const throwErrorCode = (UploadErrorCode, detail) => {
-  const errorCode = UploadErrorCode;
-  let errorResponse;
-  if (errorCode && typeof errorCode === "string" && errorCode in ErrorMap) {
-    errorResponse = ErrorMap[errorCode];
-  }
-  const message = detail || (errorResponse?.body && typeof errorResponse.body === "object" && "message" in errorResponse.body ? errorResponse.body.message : void 0) || errorResponse?.message || "UnknownError" /* UNKNOWN_ERROR */;
-  const error = new UploadError(errorCode, message);
-  error.UploadErrorCode = errorCode;
-  if (typeof detail === "string") {
-    error.detail = detail;
-  }
-  throw error;
-};
-
-export { ERRORS, ErrorMap, UploadError, isUploadError, throwErrorCode };

package/dist/packem_shared/File-Bb3P23dr.js

@@ -1,69 +0,0 @@
-import fnv1a from '@sindresorhus/fnv1a';
-import { nanoid } from 'nanoid';
-
-const hash = (value) => fnv1a(value, { size: 64 }).toString(16);
-const extractMimeType = (meta) => {
-  if (typeof meta.mimeType === "string") {
-    return meta.mimeType;
-  }
-  if (typeof meta.type === "string") {
-    return meta.type;
-  }
-  if (typeof meta.filetype === "string") {
-    return meta.filetype;
-  }
-  return void 0;
-};
-const extractOriginalName = (meta) => {
-  if (typeof meta.name === "string") {
-    return meta.name;
-  }
-  if (typeof meta.title === "string") {
-    return meta.title;
-  }
-  if (typeof meta.originalName === "string") {
-    return meta.originalName;
-  }
-  if (typeof meta.filename === "string") {
-    return meta.filename;
-  }
-  return void 0;
-};
-const generateFileId = (file) => {
-  const { metadata, originalName, size } = file;
-  const mtime = String(metadata.lastModified ?? Date.now());
-  return [originalName, size, mtime].filter(Boolean).map(String).map((value) => hash(value)).join("-");
-};
-class File {
-  bytesWritten = Number.NaN;
-  contentType;
-  originalName;
-  id;
-  metadata;
-  name = "";
-  size;
-  status;
-  expiredAt;
-  createdAt;
-  modifiedAt;
-  hash;
-  content;
-  ETag;
-  constructor({ contentType, expiredAt, metadata = {}, originalName, size }) {
-    this.metadata = metadata;
-    this.originalName = originalName || extractOriginalName(metadata) || (this.id = nanoid());
-    this.contentType = contentType || extractMimeType(metadata) || "application/octet-stream";
-    this.expiredAt = expiredAt;
-    if (typeof size === "string" || typeof size === "number") {
-      this.size = Number(size);
-    } else if (typeof metadata.size === "string" || typeof metadata.size === "number") {
-      this.size = Number(metadata.size);
-    }
-    if (typeof this.size === "number" && this.size <= 0) {
-      this.size = void 0;
-    }
-    this.id ||= generateFileId(this);
-  }
-}
-
-export { File as default };

package/dist/packem_shared/GCSConfig-vPP22kN6.js

@@ -1,11 +0,0 @@
-const GCSConfig = {
-  authScopes: [
-    "https://www.googleapis.com/auth/iam",
-    "https://www.googleapis.com/auth/cloud-platform",
-    "https://www.googleapis.com/auth/devstorage.full_control"
-  ],
-  storageAPI: "https://storage.googleapis.com/storage/v1/b",
-  uploadAPI: "https://storage.googleapis.com/upload/storage/v1/b"
-};
-
-export { GCSConfig as default };

package/dist/packem_shared/GCSFile-BIEunhAN.js

@@ -1,8 +0,0 @@
-import File from './File-Bb3P23dr.js';
-
-class GCSFile extends File {
-  GCSUploadURI;
-  uri;
-}
-
-export { GCSFile as default };

package/dist/packem_shared/GCSMetaStorage-CHZKMe7N.js

@@ -1,7 +0,0 @@
-import 'node:crypto';
-import 'gaxios';
-import 'google-auth-library';
-export { G as default } from './gcs-meta-storage-CJ8Uts_d.js';
-import './MetaStorage-pECeFOad.js';
-import './Metadata-DRLXeJ0F.js';
-import './GCSConfig-vPP22kN6.js';

package/dist/packem_shared/GCStorage-C-gAuP0j.js

@@ -1,406 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { request } from 'gaxios';
-import { GoogleAuth } from 'google-auth-library';
-import { r as retryOptions, G as GCSMetaStorage, g as getRangeEnd, p as package_, b as buildContentRange } from './gcs-meta-storage-CJ8Uts_d.js';
-import { p as partMatch, d as detectFileTypeFromStream, g as getFileStatus } from './part-match-BMNqHDYD.js';
-import { throwErrorCode, ERRORS } from './ERRORS-D0apMqnc.js';
-import { B as BaseStorage, t as toMilliseconds } from './storage-C6NSXb8h.js';
-import { L as LocalMetaStorage } from './local-meta-storage-By-3SNBI.js';
-import GCSConfig from './GCSConfig-vPP22kN6.js';
-import GCSFile from './GCSFile-BIEunhAN.js';
-import { h as hasContent } from './has-content-CY66ehMK.js';
-
-class FetchError extends Error {
-  constructor(message, code, config) {
-    super(message);
-    this.code = code;
-    this.config = config;
-  }
-  name = "FetchError";
-}
-
-const validateStatus = (code) => code >= 200 && code < 300 || code === 308 || code === 499;
-class GCStorage extends BaseStorage {
-  static name = "gcs";
-  checksumTypes = ["md5", "crc32c"];
-  meta;
-  bucket;
-  authClient;
-  storageBaseURI;
-  uploadBaseURI;
-  isCustomEndpoint = false;
-  retryOptions = {};
-  useAuthWithCustomEndpoint;
-  userProject;
-  constructor(config) {
-    super(config);
-    const bucketName = config.bucket || process.env.GCS_BUCKET;
-    if (!bucketName) {
-      throw new Error("GCS bucket is not defined");
-    }
-    if (!config.projectId) {
-      throw new Error("Sorry, we cannot connect to Cloud Services without a project ID.");
-    }
-    this.bucket = bucketName;
-    this.storageBaseURI = `${config.storageAPI || GCSConfig.storageAPI}/${this.bucket}/o`;
-    this.uploadBaseURI = `${config.uploadAPI || GCSConfig.uploadAPI}/${this.bucket}/o`;
-    this.isCustomEndpoint = new URL(this.storageBaseURI).hostname !== "storage.googleapis.com";
-    const { retryOptions: retryOptions$1, useAuthWithCustomEndpoint, userProject } = config;
-    this.userProject = userProject;
-    this.useAuthWithCustomEndpoint = useAuthWithCustomEndpoint || false;
-    this.retryOptions = {
-      ...retryOptions,
-      ...retryOptions$1
-    };
-    config.scopes ||= GCSConfig.authScopes;
-    this.authClient = new GoogleAuth(config);
-    const { bucket, metaStorage, metaStorageConfig, projectId } = config;
-    if (metaStorage) {
-      this.meta = metaStorage;
-    } else {
-      let metaConfig = { ...config, ...metaStorageConfig, logger: this.logger };
-      const localMeta = "directory" in metaConfig;
-      if (localMeta) {
-        this.logger?.debug("Using local meta storage");
-        this.meta = new LocalMetaStorage(metaConfig);
-      } else {
-        if (bucket === metaConfig.bucket && projectId === metaConfig.projectId) {
-          metaConfig = { ...metaConfig, authClient: this.authClient };
-        }
-        this.meta = new GCSMetaStorage(metaConfig);
-      }
-    }
-    this.isReady = false;
-    this.accessCheck().then(() => {
-      this.isReady = true;
-      return void 0;
-    }).catch((error) => {
-      this.logger?.error("Storage access check failed: %O", error);
-    });
-  }
-  normalizeError(error) {
-    if (error.config) {
-      const statusCode = +error.code || 500;
-      return {
-        code: `GCS${statusCode}`,
-        message: error.message,
-        name: error.name,
-        retryable: statusCode >= 499,
-        statusCode
-      };
-    }
-    return {
-      code: "GenericUploadError",
-      message: `[${this.constructor.name}] ${error.message}`,
-      name: error.name,
-      statusCode: 500
-    };
-  }
-  async create(config) {
-    return this.instrumentOperation("create", async () => {
-      const processedConfig = { ...config };
-      if (config.ttl) {
-        const ttlMs = typeof config.ttl === "string" ? toMilliseconds(config.ttl) : config.ttl;
-        if (ttlMs !== void 0) {
-          processedConfig.expiredAt = Date.now() + ttlMs;
-        }
-      }
-      const file = new GCSFile(processedConfig);
-      file.name = this.namingFunction(file);
-      await this.validate(file);
-      try {
-        const existing = await this.getMeta(file.id);
-        existing.bytesWritten = await this.internalWrite(existing);
-        return existing;
-      } catch {
-      }
-      const headers = {
-        "Content-Type": "application/json; charset=utf-8",
-        "X-Goog-Upload-Command": "start",
-        "X-Goog-Upload-Protocol": "resumable",
-        "X-Upload-Content-Length": file.size.toString(),
-        "X-Upload-Content-Type": file.contentType
-      };
-      const options = {
-        body: JSON.stringify({ metadata: file.metadata }),
-        headers,
-        method: "POST",
-        params: { name: file.name, size: file.size, uploadType: "resumable" },
-        url: this.uploadBaseURI
-      };
-      const response = await this.makeRequest(options);
-      if (response.status !== 200) {
-        throw new Error("Expected 200 response from GCS");
-      }
-      const hdr = response.headers.get("X-Goog-Upload-Status") || response.headers.get("x-goog-upload-status");
-      if (hdr !== "active") {
-        throw new Error(`X-Goog-Upload-Status response header expected 'active' got: ${hdr}`);
-      }
-      file.uri = response.headers.get("location");
-      if (this.config.clientDirectUpload) {
-        file.GCSUploadURI = file.uri;
-        this.logger?.debug("send uploadURI to client: %s", file.GCSUploadURI);
-        file.status = "created";
-        return file;
-      }
-      file.bytesWritten = 0;
-      await this.saveMeta(file);
-      file.status = "created";
-      await this.onCreate(file);
-      return file;
-    });
-  }
-  async write(part) {
-    return this.instrumentOperation("write", async () => {
-      let file;
-      if ("contentType" in part && "metadata" in part && !("body" in part) && !("start" in part)) {
-        file = part;
-      } else {
-        file = await this.getMeta(part.id);
-        await this.checkIfExpired(file);
-      }
-      if (file.status === "completed") {
-        return file;
-      }
-      if (!partMatch(part, file)) {
-        return throwErrorCode(ERRORS.FILE_CONFLICT);
-      }
-      await this.lock(part.id);
-      try {
-        if (hasContent(part) && (file.bytesWritten === 0 || Number.isNaN(file.bytesWritten)) && (!file.contentType || file.contentType === "application/octet-stream")) {
-          try {
-            const { fileType, stream: detectedStream } = await detectFileTypeFromStream(part.body);
-            if (fileType?.mime) {
-              file.contentType = fileType.mime;
-            }
-            part.body = detectedStream;
-          } catch {
-          }
-        }
-        file.bytesWritten = await this.internalWrite({ ...file, ...part });
-        file.status = getFileStatus(file);
-        if (file.status === "completed") {
-          file.uri = `${this.storageBaseURI}/${file.name}`;
-          await this.internalOnComplete(file);
-        }
-      } finally {
-        await this.unlock(part.id);
-      }
-      return file;
-    });
-  }
-  /**
-   * Deletes an upload and its metadata.
-   * @param query File query containing the file ID to delete.
-   * @param query.id File ID to delete.
-   * @returns Promise resolving to the deleted file object with status: "deleted".
-   * @throws {UploadError} If the file metadata cannot be found.
-   */
-  async delete({ id }) {
-    return this.instrumentOperation("delete", async () => {
-      const file = await this.getMeta(id);
-      if (!file.uri) {
-        throw new Error(`File ${id} does not have a valid URI`);
-      }
-      file.status = "deleted";
-      await Promise.all([this.makeRequest({ method: "DELETE", url: file.uri, validateStatus }), this.deleteMeta(file.id)]);
-      const deletedFile = { ...file };
-      await this.onDelete(deletedFile);
-      return deletedFile;
-    });
-  }
-  /**
-   * Copies an upload file to a new location.
-   * @param name Source file name/ID.
-   * @param destination Destination file name/ID.
-   * @returns Promise resolving to the copied file object.
-   * @throws {UploadError} If the source file cannot be found.
-   */
-  async copy(name, destination) {
-    return this.instrumentOperation("copy", async () => {
-      const baseUrl = new URL(`/${this.bucket}/${name}`, "file://");
-      const resolvedUrl = new URL(encodeURI(destination), baseUrl);
-      const newPath = resolvedUrl.pathname;
-      const [, bucket, ...pathSegments] = newPath.split("/");
-      const filename = pathSegments.join("/");
-      const url = `${this.storageBaseURI}/${name}/rewriteTo/b/${bucket}/o/${filename}`;
-      let progress = {};
-      const requestOptions = {
-        body: "",
-        headers: { "Content-Type": "application/json" },
-        method: "POST",
-        url
-      };
-      do {
-        requestOptions.body = progress.rewriteToken ? JSON.stringify({ rewriteToken: progress.rewriteToken }) : "";
-        const response = await this.makeRequest(requestOptions);
-        progress = response.data || {};
-      } while (progress.rewriteToken);
-      return await this.getMeta(destination);
-    });
-  }
-  /**
-   * Moves an upload file to a new location.
-   * @param name Source file name/ID.
-   * @param destination Destination file name/ID.
-   * @returns Promise resolving to the moved file object.
-   * @throws {UploadError} If the source file cannot be found.
-   */
-  async move(name, destination) {
-    return this.instrumentOperation("move", async () => {
-      const copiedFile = await this.copy(name, destination);
-      const url = `${this.storageBaseURI}/${name}`;
-      await this.makeRequest({ method: "DELETE", url });
-      return copiedFile;
-    });
-  }
-  /**
-   * Gets an uploaded file by ID with content buffer.
-   * @param query File query object containing the file ID.
-   * @param query.id Unique identifier of the file to retrieve.
-   * @returns Promise resolving to file object with content buffer.
-   * @throws {UploadError} If the file cannot be found (ERRORS.FILE_NOT_FOUND) or has expired (ERRORS.GONE).
-   */
-  async get({ id }) {
-    return this.instrumentOperation("get", async () => {
-      const { data } = await this.makeRequest({ params: { alt: "json" }, url: `${this.storageBaseURI}/${id}` });
-      await this.checkIfExpired({ expiredAt: data.timeDeleted });
-      if (!data.uri) {
-        throw new Error("File URI not found");
-      }
-      const response = await this.makeRequest({ params: { alt: "media" }, url: data.uri });
-      const responseData = response.data;
-      let bufferData;
-      if (typeof responseData === "string") {
-        bufferData = Buffer.from(responseData, "utf8");
-      } else if (responseData && typeof responseData === "object" && "data" in responseData) {
-        const dataValue = responseData.data;
-        bufferData = Buffer.from(dataValue);
-      } else {
-        bufferData = Buffer.from(responseData);
-      }
-      return {
-        ...data,
-        content: bufferData
-      };
-    });
-  }
-  /**
-   * Checks if a file exists by verifying both metadata and the actual GCS object.
-   * Returns true only if both the metadata and the GCS object exist.
-   * @param query File query containing the file ID to check.
-   * @returns Promise resolving to true if both metadata and GCS object exist, false otherwise.
-   */
-  async exists({ id }) {
-    return this.instrumentOperation("exists", async () => {
-      try {
-        await this.getMeta(id);
-        await this.makeRequest({
-          method: "HEAD",
-          url: `${this.storageBaseURI}/${id}`
-        });
-        return true;
-      } catch (error) {
-        const errorWithStatus = error;
-        const statusCode = errorWithStatus.status || errorWithStatus.response?.status;
-        if (statusCode === 404) {
-          return false;
-        }
-        return false;
-      }
-    });
-  }
-  async list(limit = 1e3) {
-    return this.instrumentOperation(
-      "list",
-      async () => {
-        const items = [];
-        let truncated = true;
-        let parameters = { params: { maxResults: limit }, url: this.storageBaseURI };
-        while (truncated) {
-          try {
-            const { data } = await this.makeRequest(parameters);
-            (data?.items || []).forEach(({ name, timeCreated, updated }) => {
-              items.push({
-                createdAt: timeCreated,
-                id: name,
-                modifiedAt: updated
-              });
-            });
-            truncated = data?.nextPageToken !== void 0;
-            if (truncated) {
-              parameters = { ...parameters, params: { ...parameters.params, pageToken: data.nextPageToken } };
-            }
-          } catch (error) {
-            const httpError = this.normalizeError(error instanceof Error ? error : new Error(String(error)));
-            await this.onError(httpError);
-            throw error;
-          }
-        }
-        return items;
-      },
-      { limit }
-    );
-  }
-  async internalWrite(part) {
-    const { body, bytesWritten, size, uri = "" } = part;
-    const contentRange = buildContentRange(part);
-    const options = { method: "PUT" };
-    if (body?.on) {
-      const abortController = new AbortController();
-      body.on("aborted", () => abortController.abort());
-      options.body = body;
-      options.signal = abortController.signal;
-    }
-    options.headers = {
-      Accept: "application/json",
-      "Content-Range": contentRange,
-      ...size === bytesWritten ? { "X-Goog-Upload-Command": "upload, finalize" } : {}
-    };
-    try {
-      const response = await this.makeRequest({ url: uri, ...options });
-      if (response.status === 308) {
-        const range = response.headers.get("range");
-        return range ? getRangeEnd(range) : 0;
-      }
-      if (response.status === 200) {
-        this.logger?.debug("uploaded %O", response.data);
-        return size;
-      }
-      throw new FetchError(String(response.data), `GCS${response.status}`, { uri });
-    } catch (error) {
-      this.logger?.error(uri, error);
-      const httpError = this.normalizeError(error instanceof Error ? error : new Error(String(error)));
-      await this.onError(httpError);
-      throw error;
-    }
-  }
-  internalOnComplete = (file) => this.deleteMeta(file.id);
-  async makeRequest(data) {
-    if (typeof data.url === "string") {
-      data.url = data.url.replaceAll("/:", ":");
-    }
-    data = {
-      ...data,
-      headers: {
-        "User-Agent": `${package_.name}/${package_.version}`,
-        "x-goog-api-client": `gl-node/${process.versions.node} gccl/${package_.version} gccl-invocation-id/${randomUUID()}`
-      },
-      params: {
-        ...this.userProject === void 0 ? {} : { userProject: this.userProject }
-      },
-      retry: true,
-      retryConfig: this.retryOptions,
-      timeout: 6e4
-    };
-    if (this.isCustomEndpoint && !this.useAuthWithCustomEndpoint) {
-      return request(data);
-    }
-    return this.authClient.request(data);
-  }
-  async accessCheck() {
-    return this.makeRequest({ url: this.storageBaseURI.replace("/o", "") });
-  }
-}
-
-export { GCStorage as default };

package/dist/packem_shared/LocalMetaStorage-CZHhKkMd.js

@@ -1,7 +0,0 @@
-import 'node:fs/promises';
-import 'node:os';
-import './ERRORS-D0apMqnc.js';
-import './MetaStorage-pECeFOad.js';
-import './Metadata-DRLXeJ0F.js';
-import './path-CR6YkPXX-7R1-9CMk.js';
-export { L as default } from './local-meta-storage-By-3SNBI.js';