@visulima/storage 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/packem_shared/NetlifyBlobStorage-CLPtjHqd.js

@@ -1,376 +0,0 @@
-import { getStore } from '@netlify/blobs';
-import { g as getFileStatus, p as partMatch, a as detectFileTypeFromBuffer } from './part-match-BMNqHDYD.js';
-import { B as BaseStorage, t as toMilliseconds, u as updateMetadata } from './storage-C6NSXb8h.js';
-import { createRetryWrapper } from './isRetryableError-Dycp7127.js';
-import { L as LocalMetaStorage } from './local-meta-storage-By-3SNBI.js';
-import NetlifyBlobFile from './NetlifyBlobFile-CXzyjqrD.js';
-import { u as updateSize } from './update-size-CCGm6i1J.js';
-import { h as hasContent } from './has-content-CY66ehMK.js';
-
-class NetlifyBlobStorage extends BaseStorage {
-  static name = "netlify-blob";
-  checksumTypes = ["md5"];
-  meta;
-  storeName;
-  siteID;
-  token;
-  store;
-  retry;
-  constructor(config) {
-    super(config);
-    this.storeName = config.storeName || "default";
-    this.siteID = config.siteID || process.env.NETLIFY_SITE_ID;
-    this.token = config.token || process.env.NETLIFY_TOKEN;
-    this.store = getStore({
-      name: this.storeName,
-      ...this.siteID && { siteID: this.siteID },
-      ...this.token && { token: this.token }
-    });
-    const retryConfig = {
-      backoffMultiplier: 2,
-      initialDelay: 1e3,
-      maxDelay: 3e4,
-      maxRetries: 3,
-      retryableStatusCodes: [408, 429, 500, 502, 503, 504],
-      shouldRetry: (error) => {
-        if (error instanceof Error) {
-          const errorWithCode = error;
-          const errorCode = errorWithCode.code;
-          if (errorCode === "ECONNRESET" || errorCode === "ETIMEDOUT" || errorCode === "ENOTFOUND" || errorCode === "ECONNREFUSED") {
-            return true;
-          }
-        }
-        const errorWithStatus = error;
-        return Boolean(errorWithStatus.status && [408, 429, 500, 502, 503, 504].includes(errorWithStatus.status));
-      },
-      ...config.retryConfig
-    };
-    this.retry = createRetryWrapper(retryConfig);
-    const { metaStorage, metaStorageConfig } = config;
-    this.meta = metaStorage || new LocalMetaStorage(metaStorageConfig);
-    this.isReady = true;
-  }
-  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;
-        processedConfig.expiredAt = ttlMs === void 0 ? void 0 : Date.now() + ttlMs;
-      }
-      const file = new NetlifyBlobFile(processedConfig);
-      file.name = this.namingFunction(file);
-      await this.validate(file);
-      try {
-        const existing = await this.getMeta(file.id);
-        if (existing.bytesWritten >= 0) {
-          return existing;
-        }
-      } catch {
-      }
-      file.bytesWritten = 0;
-      file.status = getFileStatus(file);
-      await this.saveMeta(file);
-      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 (part.size !== void 0) {
-        updateSize(file, part.size);
-      }
-      if (!partMatch(part, file)) {
-        throw new Error("File part does not match");
-      }
-      await this.lock(part.id);
-      try {
-        if (hasContent(part)) {
-          if (this.isUnsupportedChecksum(part.checksumAlgorithm)) {
-            throw new Error("Unsupported checksum algorithm");
-          }
-          const chunks = [];
-          const stream = part.body;
-          for await (const chunk of stream) {
-            chunks.push(Buffer.from(chunk));
-          }
-          const buffer = Buffer.concat(chunks);
-          if ((file.bytesWritten === 0 || Number.isNaN(file.bytesWritten)) && (!file.contentType || file.contentType === "application/octet-stream")) {
-            try {
-              const fileType = await detectFileTypeFromBuffer(buffer);
-              if (fileType?.mime) {
-                file.contentType = fileType.mime;
-              }
-            } catch {
-            }
-          }
-          await this.retry(
-            () => this.store.set(file.name, buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), {
-              metadata: {
-                contentType: file.contentType,
-                ...file.metadata
-              }
-            })
-          );
-          file.pathname = file.name;
-          file.url = this.getBlobUrl(file.name);
-          file.bytesWritten = buffer.length;
-        }
-        file.status = getFileStatus(file);
-        if (file.status === "completed") {
-          await this.internalOnComplete(file);
-        }
-        await this.saveMeta(file);
-        return file;
-      } finally {
-        await this.unlock(part.id);
-      }
-    });
-  }
-  /**
-   * 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.pathname) {
-        throw new Error(`File ${id} does not have a valid pathname`);
-      }
-      file.status = "deleted";
-      try {
-        await this.retry(() => this.store.delete(file.pathname));
-      } catch (error) {
-        this.logger?.error("Failed to delete blob from Netlify Blob:", error);
-        const httpError = this.normalizeError(error instanceof Error ? error : new Error(String(error)));
-        await this.onError(httpError);
-      }
-      await this.deleteMeta(file.id);
-      const deletedFile = { ...file };
-      await this.onDelete(deletedFile);
-      return deletedFile;
-    });
-  }
-  /**
-   * Checks if a file exists by verifying both metadata and the actual Netlify Blob.
-   * Returns true only if both the metadata and the blob exist.
-   * @param query File query containing the file ID to check.
-   * @returns Promise resolving to true if both metadata and blob exist, false otherwise.
-   */
-  async exists({ id }) {
-    return this.instrumentOperation("exists", async () => {
-      try {
-        const file = await this.getMeta(id);
-        if (!file.pathname || file.pathname.length <= 0) {
-          return false;
-        }
-        const blob = await this.retry(() => this.store.get(file.pathname, { type: "blob" }));
-        return blob !== null && blob !== void 0;
-      } catch {
-        return false;
-      }
-    });
-  }
-  async get({ id }) {
-    return this.instrumentOperation("get", async () => {
-      const file = await this.checkIfExpired(await this.getMeta(id));
-      if (!file.pathname || file.pathname.length <= 0) {
-        throw new Error("File pathname not found");
-      }
-      const blob = await this.retry(() => this.store.get(file.pathname, { type: "blob" }));
-      if (!blob) {
-        throw new Error("File not found in Netlify Blob");
-      }
-      let arrayBuffer;
-      if (typeof blob === "string") {
-        arrayBuffer = Buffer.from(blob, "utf8").buffer;
-      } else if (blob && typeof blob === "object" && "arrayBuffer" in blob && typeof blob.arrayBuffer === "function") {
-        arrayBuffer = await this.retry(() => blob.arrayBuffer());
-      } else {
-        throw new Error("Invalid blob type returned from Netlify Blob");
-      }
-      const content = Buffer.from(arrayBuffer);
-      let blobMetadata = null;
-      try {
-        const metadata = await this.store.getMetadata?.(file.pathname);
-        blobMetadata = metadata ?? null;
-      } catch {
-      }
-      return {
-        content,
-        contentType: blobMetadata?.contentType || file.contentType,
-        ETag: file.ETag,
-        expiredAt: file.expiredAt,
-        id,
-        metadata: {
-          ...file.metadata,
-          ...blobMetadata?.metadata
-        },
-        modifiedAt: file.modifiedAt,
-        name: file.name,
-        originalName: file.originalName,
-        size: file.size || content.length
-      };
-    });
-  }
-  /**
-   * 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 sourceFile = await this.getMeta(name);
-      if (!sourceFile.pathname) {
-        throw new Error("Source file pathname not found");
-      }
-      const sourceBlob = await this.retry(() => this.store.get(sourceFile.pathname, { type: "blob" }));
-      if (!sourceBlob) {
-        throw new Error("Source file not found in Netlify Blob");
-      }
-      let sourceMetadata = null;
-      try {
-        const storeWithMetadata = this.store;
-        if (storeWithMetadata.getMetadata && sourceFile.pathname) {
-          sourceMetadata = await storeWithMetadata.getMetadata(sourceFile.pathname);
-        }
-      } catch {
-      }
-      let arrayBuffer;
-      if (typeof sourceBlob === "string") {
-        arrayBuffer = Buffer.from(sourceBlob, "utf8").buffer;
-      } else if (sourceBlob && typeof sourceBlob === "object" && "arrayBuffer" in sourceBlob) {
-        const blobWithArrayBuffer = sourceBlob;
-        arrayBuffer = await this.retry(() => blobWithArrayBuffer.arrayBuffer());
-      } else {
-        throw new Error("Invalid blob type returned from Netlify Blob");
-      }
-      const buffer = Buffer.from(arrayBuffer);
-      await this.retry(
-        () => this.store.set(destination, buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), {
-          metadata: sourceMetadata || {
-            contentType: sourceFile.contentType,
-            ...sourceFile.metadata
-          }
-        })
-      );
-      const copiedFile = {
-        ...sourceFile,
-        id: destination,
-        name: destination,
-        pathname: destination,
-        url: this.getBlobUrl(destination)
-      };
-      await this.saveMeta(copiedFile);
-      return copiedFile;
-    });
-  }
-  /**
-   * 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);
-      await this.delete({ id: name });
-      return copiedFile;
-    });
-  }
-  /**
-   * Updates file metadata with user-provided key-value pairs.
-   * Updates the metadata file (overwrites it) but does not update Netlify Blob metadata
-   * since the Netlify Blob API doesn't support metadata updates.
-   * @param query File query containing the file ID to update.
-   * @param query.id File ID to update.
-   * @param metadata Partial file object containing fields to update.
-   * @returns Promise resolving to the updated file object.
-   * @throws {UploadError} If the file cannot be found (ERRORS.FILE_NOT_FOUND).
-   * @remarks
-   * Supports TTL (time-to-live) option: if metadata contains a 'ttl' field,
-   * it will be converted to an 'expiredAt' timestamp.
-   * TTL can be a number (milliseconds) or string (e.g., "1h", "30m", "7d").
-   */
-  async update({ id }, metadata) {
-    return this.instrumentOperation("update", async () => {
-      const file = await this.getMeta(id);
-      const processedMetadata = { ...metadata };
-      if ("ttl" in processedMetadata && processedMetadata.ttl !== void 0) {
-        const ttlValue = processedMetadata.ttl;
-        const ttlMs = typeof ttlValue === "string" ? toMilliseconds(ttlValue) : ttlValue;
-        if (ttlMs !== void 0) {
-          processedMetadata.expiredAt = Date.now() + ttlMs;
-        }
-        delete processedMetadata.ttl;
-      }
-      updateMetadata(file, processedMetadata);
-      await this.saveMeta(file);
-      const updatedFile = { ...file, status: "updated" };
-      await this.onUpdate(updatedFile);
-      return updatedFile;
-    });
-  }
-  async list(limit = 1e3) {
-    return this.instrumentOperation(
-      "list",
-      async () => {
-        const listResult = await this.retry(() => this.store.list());
-        const files = [];
-        for await (const blob of listResult.blobs) {
-          let metadata = null;
-          try {
-            const fetchedMetadata = await this.store.getMetadata?.(blob.key);
-            metadata = fetchedMetadata ?? null;
-          } catch {
-          }
-          const file = new NetlifyBlobFile({
-            contentType: metadata?.contentType || "application/octet-stream",
-            metadata: metadata?.metadata || {},
-            originalName: blob.key
-          });
-          const blobWithDates = blob;
-          file.createdAt = blobWithDates.createdAt?.toISOString();
-          file.id = blob.key;
-          file.modifiedAt = blobWithDates.updatedAt?.toISOString();
-          file.name = blob.key;
-          file.pathname = blob.key;
-          file.size = blobWithDates.size;
-          file.url = this.getBlobUrl(blob.key);
-          files.push(file);
-          if (files.length >= limit) {
-            break;
-          }
-        }
-        return files;
-      },
-      { limit }
-    );
-  }
-  internalOnComplete = (file) => this.deleteMeta(file.id);
-  /**
-   * Generate a URL for a blob in Netlify Blob store
-   * Note: Netlify Blob doesn't provide direct public URLs like Vercel Blob
-   * In production, you would typically serve these through Netlify Functions or Edge Functions
-   */
-  getBlobUrl(pathname) {
-    return `/api/blobs/${this.storeName}/${pathname}`;
-  }
-}
-
-export { NetlifyBlobStorage as default };

package/dist/packem_shared/NoOpMetrics-DhAk5rXc.js

@@ -1,10 +0,0 @@
-class NoOpMetrics {
-  increment(_name, _value, _attributes) {
-  }
-  timing(_name, _duration, _attributes) {
-  }
-  gauge(_name, _value, _attributes) {
-  }
-}
-
-export { NoOpMetrics as default };

package/dist/packem_shared/OpenTelemetryMetrics-BnxhqIaH.js

@@ -1,67 +0,0 @@
-import { metrics } from '@opentelemetry/api';
-
-class OpenTelemetryMetrics {
-  meter;
-  counters = /* @__PURE__ */ new Map();
-  histograms = /* @__PURE__ */ new Map();
-  gauges = /* @__PURE__ */ new Map();
-  /**
-   * Creates a new OpenTelemetryMetrics instance.
-   * @param meter OpenTelemetry Meter instance. If not provided, uses the default meter.
-   * @throws {Error} If \@opentelemetry/api is not installed
-   */
-  constructor(meter) {
-    this.meter = meter || metrics.getMeter("@visulima/storage", "1.0.0");
-  }
-  /**
-   * Increment a counter metric.
-   */
-  increment(name, value = 1, attributes) {
-    if (!this.counters.has(name)) {
-      const options = {
-        description: `Counter for ${name}`
-      };
-      this.counters.set(name, this.meter.createCounter(name, options));
-    }
-    const counter = this.counters.get(name);
-    if (!counter) {
-      throw new Error(`Counter ${name} was not created`);
-    }
-    counter.add(value, attributes);
-  }
-  /**
-   * Record a duration/timing metric in milliseconds.
-   */
-  timing(name, duration, attributes) {
-    if (!this.histograms.has(name)) {
-      const options = {
-        description: `Duration histogram for ${name}`,
-        unit: "ms"
-      };
-      this.histograms.set(name, this.meter.createHistogram(name, options));
-    }
-    const histogram = this.histograms.get(name);
-    if (!histogram) {
-      throw new Error(`Histogram ${name} was not created`);
-    }
-    histogram.record(duration, attributes);
-  }
-  /**
-   * Set a gauge metric value.
-   */
-  gauge(name, value, attributes) {
-    if (!this.gauges.has(name)) {
-      const options = {
-        description: `Gauge for ${name}`
-      };
-      this.gauges.set(name, this.meter.createUpDownCounter(name, options));
-    }
-    const gauge = this.gauges.get(name);
-    if (!gauge) {
-      throw new Error(`Gauge ${name} was not created`);
-    }
-    gauge.add(value, attributes);
-  }
-}
-
-export { OpenTelemetryMetrics as default };