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

package/dist/packem_shared/aws-light-meta-storage-DKJBgbR6.js

@@ -0,0 +1,446 @@
+import MetaStorage from './MetaStorage-pECeFOad.js';
+import { parseMetadata, stringifyMetadata } from './Metadata-DRLXeJ0F.js';
+import { Readable } from 'node:stream';
+import { AwsClient } from 'aws4fetch';
+import { i as isExpired } from './is-expired-CTThU1q5.js';
+
+const parseXml = (text) => {
+  const result = {};
+  const cleanText = text.replaceAll(/<\?xml[^>]*\?>/g, "").replaceAll(/xmlns[^=]*="[^"]*"/g, "");
+  const tagRegex = /<([^>]+)>([^<]*)<\/\1>/g;
+  const matches = [...cleanText.matchAll(tagRegex)];
+  for (const match of matches) {
+    const [, tagName, content] = match;
+    if (tagName && content && content.trim()) {
+      if (result[tagName]) {
+        if (!Array.isArray(result[tagName])) {
+          result[tagName] = [result[tagName]];
+        }
+        result[tagName].push(content.trim());
+      } else {
+        result[tagName] = content.trim();
+      }
+    }
+  }
+  const nestedRegex = /<([^>]+)>([\s\S]*?)<\/\1>/g;
+  let nestedMatch;
+  while ((nestedMatch = nestedRegex.exec(cleanText)) !== null) {
+    const [, tagName, innerContent] = nestedMatch;
+    if (tagName && innerContent && innerContent.includes("<")) {
+      const nested = parseXml(innerContent);
+      if (Object.keys(nested).length > 0) {
+        result[tagName] = nested;
+      }
+    }
+  }
+  return result;
+};
+class AwsLightApiAdapter {
+  aws;
+  bucket;
+  endpoint;
+  constructor(config) {
+    this.bucket = config.bucket;
+    this.endpoint = config.endpoint || `https://${config.bucket}.s3.${config.region}.amazonaws.com`;
+    this.aws = new AwsClient({
+      accessKeyId: config.accessKeyId,
+      region: config.region,
+      secretAccessKey: config.secretAccessKey,
+      service: config.service || "s3",
+      sessionToken: config.sessionToken
+    });
+  }
+  async createMultipartUpload(params) {
+    const queryParams = { uploads: "" };
+    const headers = {};
+    if (params.ContentType) {
+      headers["Content-Type"] = params.ContentType;
+    }
+    if (params.ACL) {
+      headers["x-amz-acl"] = params.ACL;
+    }
+    if (params.Metadata) {
+      for (const [key, value] of Object.entries(params.Metadata)) {
+        headers[`x-amz-meta-${key}`] = value;
+      }
+    }
+    const url = this.buildUrl(params.Key, queryParams);
+    const response = await this.aws.fetch(url, {
+      headers,
+      method: "POST"
+    });
+    const xmlText = await response.text();
+    if (!response.ok) {
+      throw new Error(`Failed to create multipart upload: ${response.status} ${xmlText}`);
+    }
+    const xml = parseXml(xmlText);
+    const uploadId = xml.UploadId || xml.InitiateMultipartUploadResult?.UploadId;
+    if (!uploadId) {
+      const error = new Error("Failed to parse UploadId from response");
+      error.retryable = false;
+      throw error;
+    }
+    return { UploadId: uploadId };
+  }
+  async uploadPart(params) {
+    const queryParams = {
+      partNumber: String(params.PartNumber),
+      uploadId: params.UploadId
+    };
+    const headers = {};
+    if (params.ContentLength) {
+      headers["Content-Length"] = String(params.ContentLength);
+    }
+    if (params.ContentMD5) {
+      headers["Content-MD5"] = params.ContentMD5;
+    }
+    const body = params.Body instanceof Readable ? Readable.toWeb(params.Body) : params.Body;
+    const url = this.buildUrl(params.Key, queryParams);
+    const response = await this.aws.fetch(url, {
+      body,
+      headers,
+      method: "PUT"
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Failed to upload part: ${response.status} ${text}`);
+    }
+    const etag = response.headers.get("ETag");
+    if (!etag) {
+      throw new Error("Failed to get ETag from response");
+    }
+    return { ETag: etag.replaceAll(/(^"|"$)/g, "") };
+  }
+  async completeMultipartUpload(params) {
+    const queryParams = { uploadId: params.UploadId };
+    const partsXml = params.Parts.map(({ ETag, PartNumber }) => `<Part><PartNumber>${PartNumber}</PartNumber><ETag>"${ETag}"</ETag></Part>`).join("");
+    const xmlBody = `<?xml version="1.0" encoding="UTF-8"?>
+<CompleteMultipartUpload xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+${partsXml}
+</CompleteMultipartUpload>`;
+    const url = this.buildUrl(params.Key, queryParams);
+    const response = await this.aws.fetch(url, {
+      body: xmlBody,
+      headers: {
+        "Content-Type": "application/xml"
+      },
+      method: "POST"
+    });
+    const xmlText = await response.text();
+    if (!response.ok) {
+      throw new Error(`Failed to complete multipart upload: ${response.status} ${xmlText}`);
+    }
+    const xml = parseXml(xmlText);
+    const result = xml.CompleteMultipartUploadResult || xml;
+    const location = result.Location || `${this.endpoint}/${params.Key}`;
+    const etag = result.ETag;
+    return {
+      ETag: etag?.replaceAll(/(^"|"$)/g, ""),
+      Location: location
+    };
+  }
+  async abortMultipartUpload(params) {
+    const queryParams = { uploadId: params.UploadId };
+    const url = this.buildUrl(params.Key, queryParams);
+    const response = await this.aws.fetch(url, {
+      method: "DELETE"
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Failed to abort multipart upload: ${response.status} ${text}`);
+    }
+  }
+  async listParts(params) {
+    const queryParams = { uploadId: params.UploadId };
+    const url = this.buildUrl(params.Key, queryParams);
+    const response = await this.aws.fetch(url, {
+      method: "GET"
+    });
+    const xmlText = await response.text();
+    if (!response.ok) {
+      throw new Error(`Failed to list parts: ${response.status} ${xmlText}`);
+    }
+    const xml = parseXml(xmlText);
+    const listPartsResult = xml.ListPartsResult || xml;
+    let parts = [];
+    if (listPartsResult.Part) {
+      parts = Array.isArray(listPartsResult.Part) ? listPartsResult.Part : [listPartsResult.Part];
+    }
+    return {
+      Parts: parts.map((part) => {
+        return {
+          ETag: part.ETag?.replaceAll(/(^"|"$)/g, ""),
+          PartNumber: Number(part.PartNumber) || 0,
+          Size: part.Size ? Number(part.Size) : void 0
+        };
+      })
+    };
+  }
+  async getObject(params) {
+    const url = this.buildUrl(params.Key);
+    const response = await this.aws.fetch(url, {
+      method: "GET"
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Failed to get object: ${response.status} ${text}`);
+    }
+    const contentLength = response.headers.get("Content-Length");
+    const contentType = response.headers.get("Content-Type");
+    const etag = response.headers.get("ETag");
+    const expires = response.headers.get("Expires");
+    const lastModified = response.headers.get("Last-Modified");
+    const metadata = {};
+    for (const [key, value] of response.headers.entries()) {
+      if (key.toLowerCase().startsWith("x-amz-meta-")) {
+        const metaKey = key.toLowerCase().replace("x-amz-meta-", "");
+        metadata[metaKey] = value;
+      }
+    }
+    const { body } = response;
+    return {
+      Body: body ? this.streamToReadable(body) : void 0,
+      ContentLength: contentLength ? Number(contentLength) : void 0,
+      ContentType: contentType || void 0,
+      ETag: etag?.replaceAll(/(^"|"$)/g, "") || void 0,
+      Expires: expires ? new Date(expires) : void 0,
+      LastModified: lastModified ? new Date(lastModified) : void 0,
+      Metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+    };
+  }
+  async headObject(params) {
+    const url = this.buildUrl(params.Key);
+    const response = await this.aws.fetch(url, {
+      method: "HEAD"
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Failed to head object: ${response.status} ${text}`);
+    }
+    const contentLength = response.headers.get("Content-Length");
+    const contentType = response.headers.get("Content-Type");
+    const etag = response.headers.get("ETag");
+    const expires = response.headers.get("Expires");
+    const lastModified = response.headers.get("Last-Modified");
+    const metadata = {};
+    for (const [key, value] of response.headers.entries()) {
+      if (key.toLowerCase().startsWith("x-amz-meta-")) {
+        const metaKey = key.toLowerCase().replace("x-amz-meta-", "");
+        metadata[metaKey] = value;
+      }
+    }
+    return {
+      ContentLength: contentLength ? Number(contentLength) : void 0,
+      ContentType: contentType || void 0,
+      ETag: etag?.replaceAll(/(^"|"$)/g, "") || void 0,
+      Expires: expires ? new Date(expires) : void 0,
+      LastModified: lastModified ? new Date(lastModified) : void 0,
+      Metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+    };
+  }
+  async deleteObject(params) {
+    const url = this.buildUrl(params.Key);
+    const response = await this.aws.fetch(url, {
+      method: "DELETE"
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Failed to delete object: ${response.status} ${text}`);
+    }
+  }
+  async copyObject(params) {
+    const headers = {
+      "x-amz-copy-source": params.CopySource
+    };
+    if (params.StorageClass) {
+      headers["x-amz-storage-class"] = params.StorageClass;
+    }
+    let url = this.buildUrl(params.Key);
+    if (params.Bucket !== this.bucket) {
+      url = url.replace(this.bucket, params.Bucket);
+    }
+    const response = await this.aws.fetch(url, {
+      headers,
+      method: "PUT"
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Failed to copy object: ${response.status} ${text}`);
+    }
+  }
+  async listObjectsV2(params) {
+    const queryParams = {
+      "list-type": "2"
+    };
+    if (params.MaxKeys) {
+      queryParams["max-keys"] = String(params.MaxKeys);
+    }
+    if (params.ContinuationToken) {
+      queryParams["continuation-token"] = params.ContinuationToken;
+    }
+    const url = this.buildUrl("", queryParams);
+    const response = await this.aws.fetch(url, {
+      method: "GET"
+    });
+    const xmlText = await response.text();
+    if (!response.ok) {
+      throw new Error(`Failed to list objects: ${response.status} ${xmlText}`);
+    }
+    const xml = parseXml(xmlText);
+    const listResult = xml.ListBucketResult || xml;
+    const contents = listResult.Contents || (Array.isArray(listResult.Contents) ? listResult.Contents : []);
+    return {
+      Contents: Array.isArray(contents) ? contents.map((item) => {
+        return {
+          Key: item.Key,
+          LastModified: item.LastModified ? new Date(String(item.LastModified)) : void 0
+        };
+      }) : [],
+      IsTruncated: listResult.IsTruncated === "true" || listResult.IsTruncated === true,
+      NextContinuationToken: listResult.NextContinuationToken
+    };
+  }
+  async getPresignedUrl(params) {
+    const queryParams = {
+      partNumber: String(params.PartNumber),
+      uploadId: params.UploadId,
+      "X-Amz-Expires": String(params.expiresIn)
+    };
+    const url = this.buildUrl(params.Key, queryParams);
+    return url;
+  }
+  async putObject(params) {
+    const url = this.buildUrl(params.Key);
+    const headers = {};
+    if (params.ContentType) {
+      headers["Content-Type"] = params.ContentType;
+    }
+    if (params.ContentLength !== void 0) {
+      headers["Content-Length"] = String(params.ContentLength);
+    }
+    if (params.Metadata) {
+      for (const [key, value] of Object.entries(params.Metadata)) {
+        headers[`x-amz-meta-${key}`] = value;
+      }
+    }
+    let body;
+    if (params.Body === void 0) {
+      body = void 0;
+    } else if (params.Body instanceof Uint8Array) {
+      body = new Uint8Array(params.Body);
+    } else if (params.Body instanceof ReadableStream) {
+      body = params.Body;
+    } else {
+      body = void 0;
+    }
+    const response = await this.aws.fetch(url, {
+      body,
+      headers,
+      method: "PUT"
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Failed to put object: ${response.status} ${text}`);
+    }
+  }
+  async checkBucketAccess(_params) {
+    const url = this.buildUrl("");
+    const response = await this.aws.fetch(url, {
+      method: "HEAD"
+    });
+    if (!response.ok && response.status !== 404) {
+      const text = await response.text();
+      throw new Error(`Failed to access bucket: ${response.status} ${text}`);
+    }
+  }
+  /**
+   * Builds S3 API URL.
+   */
+  buildUrl(key, queryParams) {
+    const url = new URL(key, this.endpoint);
+    if (queryParams) {
+      for (const [parameterKey, value] of Object.entries(queryParams)) {
+        url.searchParams.set(parameterKey, value);
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Converts ReadableStream to Readable for Node.js compatibility.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  streamToReadable(stream) {
+    return Readable.fromWeb(stream);
+  }
+}
+
+class AwsLightMetaStorage extends MetaStorage {
+  constructor(config) {
+    super(config);
+    this.config = config;
+    const bucket = config.bucket || process.env.S3_BUCKET || process.env.AWS_S3_BUCKET;
+    if (!bucket) {
+      throw new Error("S3 bucket is not defined");
+    }
+    this.bucket = bucket;
+    this.adapter = new AwsLightApiAdapter({
+      accessKeyId: config.accessKeyId,
+      bucket,
+      endpoint: config.endpoint,
+      region: config.region,
+      secretAccessKey: config.secretAccessKey,
+      service: config.service,
+      sessionToken: config.sessionToken
+    });
+    this.adapter.checkBucketAccess({ Bucket: bucket }).catch((error) => {
+      throw error;
+    });
+  }
+  adapter;
+  bucket;
+  async get(id) {
+    const Key = this.getMetaName(id);
+    const { Expires, Metadata } = await this.adapter.headObject({
+      Bucket: this.bucket,
+      Key
+    });
+    if (Expires && isExpired({ expiredAt: Expires })) {
+      await this.delete(Key);
+      throw new Error(`Metafile ${id} not found`);
+    }
+    if (Metadata?.metadata !== void 0) {
+      const file = JSON.parse(decodeURIComponent(Metadata.metadata));
+      if (file.metadata && typeof file.metadata === "string") {
+        file.metadata = parseMetadata(file.metadata);
+      }
+      return file;
+    }
+    throw new Error(`Metafile ${id} not found`);
+  }
+  async touch(id, file) {
+    return this.save(id, file);
+  }
+  async delete(id) {
+    await this.adapter.deleteObject({
+      Bucket: this.bucket,
+      Key: this.getMetaName(id)
+    });
+  }
+  async save(id, file) {
+    const transformedMetadata = { ...file };
+    if (transformedMetadata.metadata) {
+      transformedMetadata.metadata = stringifyMetadata(file.metadata);
+    }
+    const metadata = encodeURIComponent(JSON.stringify(transformedMetadata));
+    await this.adapter.putObject({
+      Bucket: this.bucket,
+      ContentLength: 0,
+      ContentType: "application/json",
+      Key: this.getMetaName(id),
+      Metadata: { metadata }
+    });
+    return file;
+  }
+}
+
+export { AwsLightMetaStorage as A, AwsLightApiAdapter as a };

package/dist/packem_shared/backblaze-BlMnIcBC.js

@@ -0,0 +1,20 @@
+const backblaze = (parameters) => {
+  const { applicationKey, applicationKeyId, region } = parameters ?? {
+    applicationKey: process.env.AWS_SECRET_ACCESS_KEY || process.env.B2_APP_KEY || process.env.BACKBLAZE_APP_KEY,
+    applicationKeyId: process.env.AWS_ACCESS_KEY_ID || process.env.B2_APP_KEY_ID || process.env.BACKBLAZE_APP_KEY_ID,
+    region: process.env.AWS_REGION || process.env.B2_REGION || process.env.BACKBLAZE_REGION
+  };
+  if (!region || !applicationKeyId || !applicationKey) {
+    throw new Error("Missing required parameters for Backblaze B2 client.");
+  }
+  return {
+    credentials: {
+      accessKeyId: applicationKeyId,
+      secretAccessKey: applicationKey
+    },
+    endpoint: `https://s3.${region}.backblazeb2.com`,
+    region
+  };
+};
+
+export { backblaze, backblaze as default };