@engineers/gcloud-storage 0.0.0-temp

package/index.mjs

@@ -0,0 +1,293 @@
+// src/index.ts
+import {
+  Storage
+} from "@google-cloud/storage";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import stripJsonComments from "strip-json-comments";
+import { URL } from "node:url";
+
+// ../javascript/src/objects.ts
+function objectType(object) {
+  return Object.prototype.toString.call(object).replace("[object ", "").replace("]", "").toLowerCase();
+}
+
+// ../javascript/src/string.ts
+function cleanString(value, options = {}) {
+  let opts = {
+    // remove '//' comments
+    // it is better to disable this option to avoid removing comment-like strings by mistake
+    // suc as `https://`
+    removeComments: false,
+    // remove break lines for multi-line string
+    removeBreakLines: true,
+    // trim each line of the multi-line string
+    trim: false,
+    ...options
+  };
+  if (opts.removeComments)
+    value = value.replace(/\s*\/\/.*$/gm, "");
+  if (opts.removeBreakLines)
+    value = value.split("\n").map((line) => opts.trim ? line.trim() : line).join("");
+  if (opts.trim)
+    value = value.trim();
+  return value;
+}
+
+// ../javascript/src/regex.ts
+function escape(value) {
+  return value.replace(/[$()*+./?[\\\]^{|}]/g, "\\$&");
+}
+function clean(value, options = {}) {
+  value = cleanString(value, options);
+  return options.escape ? escape(value) : value;
+}
+function toRegExp(value, optionsOrFlags = {}) {
+  let opts = {
+    delimiter: "",
+    ...typeof optionsOrFlags === "string" ? { flags: optionsOrFlags } : optionsOrFlags
+  };
+  if (typeof value === "string") {
+    value = clean(value, opts);
+  } else if (Array.isArray(value)) {
+    value = value.map(
+      (element) => (
+        // we don't need to escape a RegExp pattern, only escape strings
+        `(?:${element instanceof RegExp ? element.source : clean(element.toString(), opts)})`
+      )
+    ).join(opts.delimiter);
+  } else if (value instanceof RegExp) {
+  } else {
+    throw new TypeError(`value ${value} must be of type Pattern`);
+  }
+  return new RegExp(value, opts.flags);
+}
+
+// ../javascript/src/patterns.ts
+var ipv4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|\d)\.?){4}$/;
+var v6segment = "[a-fA-F\\d]{1,4}";
+var ipv6 = toRegExp(
+  `(?:(?:${v6segment}:){7}(?:${v6segment}|:)|(?:${v6segment}:){6}(?:${ipv4}|:${v6segment}|:)|(?:${v6segment}:){5}(?::${ipv4}|(?::${v6segment}){1,2}|:)| (?:${v6segment}:){4}(?:(?::${v6segment}){0,1}:${ipv4}|(?::${v6segment}){1,3}|:)| (?:${v6segment}:){3}(?:(?::${v6segment}){0,2}:${ipv4}|(?::${v6segment}){1,4}|:)|(?:${v6segment}:){2}(?:(?::${v6segment}){0,3}:${ipv4}|(?::${v6segment}){1,5}|:)|(?:${v6segment}:){1}(?:(?::${v6segment}){0,4}:${ipv4}|(?::${v6segment}){1,6}|:)|(?::(?:(?::${v6segment}){0,5}:${ipv4}|(?::${v6segment}){1,7}|:)))(?:%[0-9a-zA-Z]{1,})?`,
+  { removeComments: false }
+);
+var ip = toRegExp([ipv4, ipv6], { delimiter: "|" });
+var rootDomain = /^([\dA-Za-z][\dA-Za-z-]{2,62})\.(\w{2,3})(?:\.([A-Za-z]{2}))?$/;
+var domain = toRegExp(
+  [
+    // subdomain
+    // todo: RegExp captures the latest group match only, instead of capturing all of the repeating patterns
+    // https://stackoverflow.com/a/37004214/12577650
+    /^((?:([\dA-Za-z][\dA-Za-z-]{0,62})+\.)*)/,
+    // remove the first '^' from '^---' or '(?:^---)'
+    rootDomain.source.replace("^", "")
+  ],
+  { delimiter: "" }
+);
+var email = toRegExp([/^([a-z]+\w+)@/, domain.source.replace("^", "")], {
+  delimiter: ""
+});
+var unallowedUrlChars = ` "'\`
+<>[\\]`;
+var tdl = "com|net|org";
+var link = toRegExp(
+  `((?:ftp|https?://[^${unallowedUrlChars}]+)|(?:[^${unallowedUrlChars}\\/]+\\.(?:${tdl})(?:\\.[a-z]{2}){0,1}))(?::d+)?(?:/[^${unallowedUrlChars}]+)*`,
+  { flags: "gi" }
+);
+var plainLink = toRegExp(
+  [
+    link,
+    // doesn't followed by '*</a>', i.e: doesn't exist inside <a> tag (plain links only)
+    // https://stackoverflow.com/a/68188492/12577650
+    `(?![^<]*</a>)`
+  ],
+  { delimiter: "" }
+);
+
+// src/index.ts
+var src_default = class {
+  storage;
+  bucket;
+  rootPath;
+  /**
+   * creates a new bucket
+   *
+   * @function constructor
+   * @param options
+   * @param  bucket
+   */
+  // todo: if(bucket instanceof admin.Bucket)this.bucket=bucket
+  // constructor();
+  constructor(options) {
+    let opts = { ...options };
+    if (!opts.keyFile && !opts.keyFilename && !opts.credentials && process.env.gcloud_service_account_storage) {
+      opts.credentials = JSON.parse(process.env.gcloud_service_account_storage);
+    }
+    this.storage = new Storage(opts);
+    if (opts.bucket.includes("/")) {
+      let parts = opts.bucket.split("/");
+      opts.bucket = parts.shift();
+      this.rootPath = parts.join("/");
+    }
+    this.bucket = this.storage.bucket(opts.bucket);
+  }
+  /**
+   * uploads a file to the current bucket
+   *
+   * @function upload
+   * @param  file file path
+   * @param path
+   * @param  options UploadOptions object or destination path as string
+   * @returns Promise<UploadResponse>;  //UploadResponse=[File, API request]
+   */
+  // todo: upload / download a folder
+  upload(path, options) {
+    let opts = {
+      ...typeof options === "string" ? { destination: options } : options || {}
+    };
+    if (this.rootPath && opts?.destination) {
+      opts.destination = `${this.rootPath}/${opts.destination}`;
+    }
+    return this.bucket.upload(path.toString(), opts);
+  }
+  /**
+   * downloads a file
+   *
+   * @function download
+   * @param  file        file path
+   * @param  options DownloadOptions object or destination as string
+   * @returns Promise that resolves to:
+   *           - void: if options.destination used
+   *           - Buffer: if options.encoding is undefined
+   *           - Array or plain object: if the file is json
+   *           - string: otherwise
+   */
+  // todo: if(!options.destination)return th content as Promise<Buffer | ...>
+  // otherwise write the content into a local destination and return boolean
+  download(file, options) {
+    if (typeof file === "string" || file instanceof Buffer || file instanceof URL) {
+      file = this.bucket.file(
+        this.rootPath ? `${this.rootPath}/${file.toString()}` : file.toString()
+      );
+    }
+    let opts = Object.assign(
+      { encoding: null },
+      typeof options === "string" ? { destination: options } : options || {}
+    );
+    if (opts.destination) {
+      mkdirSync(dirname(opts.destination), { recursive: true });
+    }
+    return file.download({ ...opts }).then((result) => {
+      if (opts.destination) {
+        return;
+      }
+      let data = result[0];
+      if (opts.encoding === void 0) {
+        return data;
+      }
+      let dataString = data.toString();
+      try {
+        return file.name.slice(-5) === ".json" ? JSON.parse(stripJsonComments(dataString)) : dataString;
+      } catch {
+        return dataString;
+      }
+    });
+  }
+  /**
+   * download all files from a directory that match the provided filter
+   *
+   * @param destination the local path to download the files to
+   * @param directory the directory to be downloaded
+   * @param filter a pattern or function to filter the files to be downloaded
+   * @param options
+   * @param options.start download all files starting from the specified one (paginating behavior) (default is the first file)
+   * @param options.end download all files until the specified file (default is the last file)
+   * @returns a map of {file: result}
+   */
+  downloadAll(destination, directory, filter, options = {}) {
+    options = Object.assign({ start: 0, end: void 0 }, options || {});
+    let results = {};
+    if (!filter) {
+      filter = (file) => true;
+    } else if (filter instanceof RegExp) {
+      filter = (file) => filter.test(file);
+    }
+    if (this.rootPath) {
+      directory = `${this.rootPath}/${directory}`;
+    }
+    return this.bucket.getFiles({ prefix: directory?.toString() }).then((files) => files[0].filter((file) => filter(file.name))).then(
+      (files) => Promise.all(
+        files.slice(options.start, options.end).map(
+          (file) => this.download(file, {
+            destination: `${destination.toString()}/${file.name}`
+          }).then((result) => {
+            results[file.name] = true;
+          }).catch((error) => {
+            results[file.name] = false;
+          })
+        )
+      ).then(() => results)
+    );
+  }
+  /**
+   * writes a content to a file in the bucket
+   *
+   * @param path bucket path
+   * @param content the content to be written. if no content provided, an empty file is created
+   * @param options
+   * @returns the original content
+   */
+  write(path, content = "", options) {
+    if (this.rootPath) {
+      path = `${this.rootPath}/${path}`;
+    }
+    return this.bucket.file(path.toString()).save(
+      ["array", "object"].includes(objectType(content)) ? JSON.stringify(content) : content,
+      options
+    ).then(() => content);
+  }
+  // eslint-disable-next-line no-secrets/no-secrets
+  // https://stackoverflow.com/a/64539948/12577650
+  delete(path, options) {
+    if (this.rootPath) {
+      path = `${this.rootPath}/${path}`;
+    }
+    return this.bucket.file(path.toString()).delete(options);
+  }
+  /**
+   * check if a file exists in the bucket
+   * this method works with files only, not folders
+   * folders doesn't actually exist
+   * https://cloud.google.com/storage/docs/folders
+   *
+   * @param path file path
+   * @param options
+   * @returns boolean
+   */
+  exists(path, options) {
+    if (this.rootPath) {
+      path = `/${this.rootPath}/${path}`;
+    }
+    return this.bucket.file(path.toString()).exists(options).then((result) => result[0]);
+  }
+  /**
+   * create a new bucket, and optionally add labels to it
+   * add the desired labels as key-value pairs to metaData.labels
+   * https://cloud.google.com/storage/docs/using-bucket-labels#storage-modify-bucket-label-nodejs
+   *
+   * @param bucketName
+   * @param metaData
+   * @returns
+   */
+  create(bucketName, metaData) {
+    let { labels, ...meta } = metaData || {};
+    return this.storage.createBucket(bucketName, meta).then((result) => {
+      this.bucket.name = bucketName;
+      return labels ? this.bucket.setLabels(labels).then(() => result) : result;
+    });
+  }
+  // todo: read(file:string):Buffer
+  // todo: delete folder
+};
+export {
+  src_default as default
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@engineers/gcloud-storage",
+  "version": "0.0.0-temp",
+  "type": "module",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/its-dibo/dibo.git"
+  },
+  "homepage": "https://github.com/its-dibo/dibo#readme",
+  "bugs": {
+    "url": "https://github.com/its-dibo/dibo/issues",
+    "email": "sh.eldeeb.2010+github@gmail.com"
+  },
+  "license": "MIT",
+  "author": "Sherif Eldeeb <sh.eldeeb.2010+github@gmail.com> (https://github.com/its-dibo)",
+  "funding": [
+    {
+      "type": "paypal",
+      "url": "https://paypal.me/group99001"
+    },
+    {
+      "type": "patreon",
+      "url": "https://www.patreon.com/GoogleDev"
+    }
+  ],
+  "description": "google cloud storage",
+  "dependencies": {
+    "@google-cloud/storage": "^6.10.1"
+  },
+  "imports": {
+    "#*": "./*"
+  }
+}