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

package/dist/packem_shared/gcs-meta-storage-0tgMNnPO.js

@@ -0,0 +1,158 @@
+import { randomUUID } from 'node:crypto';
+import { request } from 'gaxios';
+import { GoogleAuth } from 'google-auth-library';
+import MetaStorage from './MetaStorage-pECeFOad.js';
+import { stringifyMetadata, parseMetadata } from './Metadata-DRLXeJ0F.js';
+import GCSConfig from './GCSConfig-vPP22kN6.js';
+import { h as hasContent } from './has-content-CY66ehMK.js';
+
+var name = "@visulima/storage";
+var version = "1.0.0-alpha.2";
+const package_ = {
+	name: name,
+	version: version};
+
+const getRangeEnd = (range) => {
+  const match = range.match(/(\d+)-(\d+)/);
+  const end = match && match[2] ? +match[2] : 0;
+  return end > 0 ? end + 1 : 0;
+};
+const buildContentRange = (part) => {
+  if (hasContent(part)) {
+    const end = part.contentLength ? part.start + part.contentLength - 1 : "*";
+    return `bytes ${part.start}-${end}/${part.size ?? "*"}`;
+  }
+  return `bytes */${part.size ?? "*"}`;
+};
+const shouldRetry = (error) => {
+  if (error.response !== void 0) {
+    const { response } = error;
+    return response?.data?.error?.errors?.map(({ reason = "" }) => {
+      if (reason === "rateLimitExceeded") {
+        return true;
+      }
+      if (reason === "userRateLimitExceeded") {
+        return true;
+      }
+      return !!(reason && reason.includes("EAI_AGAIN"));
+    }).includes(true);
+  }
+  return false;
+};
+const retryOptions = {
+  retry: 3,
+  shouldRetry,
+  statusCodesToRetry: [[408, 429, 500, 502, 503, 504], [100, 199], [429], [500, 599]]
+};
+
+class GCSMetaStorage extends MetaStorage {
+  constructor(config) {
+    super(config);
+    this.config = config;
+    const { authClient, ...metaConfig } = config;
+    const bucketName = metaConfig.bucket || process.env.GCS_BUCKET;
+    if (authClient === void 0) {
+      if (!bucketName) {
+        throw new Error("GCS bucket is not defined");
+      }
+      if (!metaConfig.projectId) {
+        throw new Error("Sorry, we cannot connect to Cloud Services without a project ID.");
+      }
+      metaConfig.scopes ||= GCSConfig.authScopes;
+      this.authClient = new GoogleAuth(metaConfig);
+    } else {
+      this.authClient = authClient;
+    }
+    this.storageBaseURI = `${metaConfig.storageAPI || GCSConfig.storageAPI}/${bucketName}/o`;
+    this.uploadBaseURI = `${metaConfig.uploadAPI || GCSConfig.uploadAPI}/${bucketName}/o`;
+    const allowedHosts = ["storage.googleapis.com"];
+    const storageBaseHost = new URL(this.storageBaseURI).hostname;
+    this.isCustomEndpoint = !allowedHosts.includes(storageBaseHost);
+    const { retryOptions: retryOptions$1, useAuthWithCustomEndpoint, userProject } = config;
+    this.userProject = userProject;
+    this.useAuthWithCustomEndpoint = useAuthWithCustomEndpoint || false;
+    this.retryOptions = {
+      ...retryOptions,
+      ...retryOptions$1
+    };
+    if (authClient === void 0) {
+      this.accessCheck().catch((error) => {
+        if (error.code === "404") {
+          throw new Error(`Bucket ${bucketName} does not exist`);
+        }
+        throw error;
+      });
+    }
+  }
+  authClient;
+  storageBaseURI;
+  uploadBaseURI;
+  isCustomEndpoint = false;
+  retryOptions = {};
+  useAuthWithCustomEndpoint;
+  userProject;
+  async save(id, file) {
+    const transformedMetadata = { ...file };
+    if (transformedMetadata.metadata) {
+      transformedMetadata.metadata = stringifyMetadata(file.metadata);
+    }
+    await this.makeRequest({
+      body: JSON.stringify(transformedMetadata),
+      headers: { "Content-Type": "application/json; charset=utf-8" },
+      method: "POST",
+      params: { name: encodeURIComponent(this.getMetaName(id)), uploadType: "media" },
+      url: this.uploadBaseURI
+    });
+    return file;
+  }
+  async delete(id) {
+    const url = this.getMetaPath(id);
+    await this.makeRequest({ method: "DELETE", url });
+  }
+  async get(id) {
+    const url = this.getMetaPath(id);
+    const { data } = await this.makeRequest({ params: { alt: "media" }, url });
+    if (data.metadata && typeof data.metadata === "string") {
+      data.metadata = parseMetadata(data.metadata);
+    }
+    return data;
+  }
+  async touch(id, file) {
+    return this.save(id, file);
+  }
+  async accessCheck() {
+    return this.makeRequest({ url: this.storageBaseURI.replace("/o", "") });
+  }
+  /**
+   * Returns metafile URL path for the given upload ID.
+   * @param id Upload ID to get metafile path for
+   * @returns Full URL path to the metafile in GCS
+   */
+  getMetaPath(id) {
+    return `${this.storageBaseURI}/${this.getMetaName(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);
+  }
+}
+
+export { GCSMetaStorage as G, buildContentRange as b, getRangeEnd as g, package_ as p, retryOptions as r };

package/dist/packem_shared/has-content-CY66ehMK.js

@@ -0,0 +1,3 @@
+const hasContent = (part) => typeof part.start === "number" && part.start >= 0 && !!part.body;
+
+export { hasContent as h };