@engineers/gcloud-storage 0.0.1 → 0.0.8-temp

package/index.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Bucket, CreateBucketRequest, File, SaveOptions, Storage, UploadResponse, StorageOptions as _StorageOptions } from '@google-cloud/storage';
+import { PathLike } from 'node:fs';
+export interface StorageOptions extends _StorageOptions {
+    bucket: string;
+    rootDir?: string;
+}
+export interface UploadOptions {
+    destination: string;
+}
+export interface DownloadOptions {
+    destination?: string;
+    encoding?: BufferEncoding | null;
+}
+export interface DeleteOptions {
+    ignoreNotFound?: boolean;
+}
+export interface ExistsOptions {
+}
+export interface CreateBucketMeta extends CreateBucketRequest {
+    labels?: {
+        [key: string]: string;
+    };
+}
+export default class {
+    storage: Storage;
+    bucket: Bucket;
+    private baseDir;
+    constructor(options: StorageOptions);
+    upload(path: PathLike, options?: UploadOptions | string): Promise<UploadResponse | void>;
+    download(file: PathLike | File, options?: DownloadOptions | string): Promise<Buffer | string | Array<any> | {
+        [key: string]: any;
+    } | void>;
+    downloadAll(destination: PathLike, directory?: PathLike, filter?: RegExp | ((file: string) => boolean), options?: {
+        start?: number;
+        end?: number;
+    }): Promise<{
+        [key: string]: boolean;
+    }>;
+    write(path: PathLike, content?: any, options?: SaveOptions): Promise<any>;
+    read(file: PathLike | File, options?: DownloadOptions | string): Promise<string | void | any[] | Buffer | {
+        [key: string]: any;
+    }>;
+    delete(path: PathLike, options?: DeleteOptions): Promise<any>;
+    exists(path: PathLike, options?: ExistsOptions): Promise<boolean>;
+    create(metaData?: CreateBucketMeta): Promise<import("@google-cloud/storage").CreateBucketResponse>;
+}

package/index.js

@@ -0,0 +1,297 @@
+// src/index.ts
+import {
+  Storage
+} from "@google-cloud/storage";
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } 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;
+  baseDir;
+  /**
+   * 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.baseDir = parts.join("/") + opts.rootDir ? "/" + opts.rootDir : "";
+    }
+    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.baseDir && opts?.destination) {
+      opts.destination = `${this.baseDir}/${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.baseDir ? `${this.baseDir}/${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.baseDir) {
+      directory = `${this.baseDir}/${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: resolve(`${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.baseDir) {
+      path = `${this.baseDir}/${path}`;
+    }
+    return this.bucket.file(path.toString()).save(
+      ["array", "object"].includes(objectType(content)) ? JSON.stringify(content) : content,
+      options
+    ).then(() => content);
+  }
+  /** an alias to download() to be compatible with node:fs functions */
+  read(file, options) {
+    return this.download(file, options);
+  }
+  // eslint-disable-next-line no-secrets/no-secrets
+  // https://stackoverflow.com/a/64539948/12577650
+  delete(path, options) {
+    if (this.baseDir) {
+      path = `${this.baseDir}/${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.baseDir) {
+      path = `/${this.baseDir}/${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 metaData
+   * @returns
+   */
+  create(metaData) {
+    let bucketName = this.bucket.name;
+    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/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,42 +1,14 @@
 {
   "name": "@engineers/gcloud-storage",
-  "version": "0.0.1",
-  "release": "semantic-release -e semantic-release-monorepo",
-  "files": [
-    "dist"
-  ],
-  "description": "google cloud storage",
+  "version": "0.0.8-temp",
+  "type": "module",
   "private": false,
+  "description": "google cloud storage",
   "dependencies": {
-    "@google-cloud/storage": "^5.19.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/eng-dibo/dibo.git"
-  },
-  "homepage": "https://github.com/eng-dibo/dibo#readme",
-  "bugs": {
-    "url": "https://github.com/eng-dibo/dibo/issues",
-    "email": "sh.eldeeb.2010+github@gmail.com"
-  },
-  "license": "MIT",
-  "author": "Sherif Eldeeb <sh.eldeeb.2010+github@gmail.com> (https://github.com/eng-dibo)",
-  "funding": [
-    {
-      "type": "paypal",
-      "url": "https://paypal.me/group99001"
-    },
-    {
-      "type": "patreon",
-      "url": "https://www.patreon.com/GoogleDev"
-    }
-  ],
-  "scripts": {
-    "build": "webpack",
-    "_publish": "npm run build && npm publish --access=public"
+    "@google-cloud/storage": "^6.10.1",
+    "strip-json-comments": "^5.0.1"
   },
-  "devDependencies": {
-    "semantic-release": "^19.0.2",
-    "semantic-release-monorepo": "^7.0.5"
+  "imports": {
+    "#*": "./*"
   }
 }

package/README.md

@@ -1,49 +0,0 @@
-# @engineers/gcloud-storage
-
-google cloud storage
-
-## install
-
-install the package and it's peer dependencies:
-
-```
-npm i @engineers/gcloud-storage
-```
-
-you can build this package and any of our packages yourself from [source](https://github.com/eng-dibo/dibo/tree/main/packages)
-
-## contributing
-
-contributing with us are very welcome.
-
-read our [contributing guide](https://github.com/eng-dibo/dibo/blob/main/CONTRIBUTING.md)
-
-## support us
-
-- [paypal](https://paypal.me/group99001)
-
-- [patreon](https://www.patreon.com/GoogleDev)
-
-## useful packages by `@engineers`
-
-- check out these useful packages that created by [@engineers organization](https://www.npmjs.com/org/engineers)
-
-  - [cache](https://github.com/eng-dibo/dibo/tree/main/packages/cache)
-  - [databases](https://github.com/eng-dibo/dibo/tree/main/packages/databases)
-  - [dibo-system](https://github.com/eng-dibo/dibo/tree/main/packages/dibo-system)
-  - [dom](https://github.com/eng-dibo/dibo/tree/main/packages/dom)
-  - [express-redirect-middleware](https://github.com/eng-dibo/dibo/tree/main/packages/express-redirect-middleware)
-  - [firebase-admin](https://github.com/eng-dibo/dibo/tree/main/packages/firebase-admin)
-  - [gcloud-storage](https://github.com/eng-dibo/dibo/tree/main/packages/gcloud-storage)
-  - [graphics](https://github.com/eng-dibo/dibo/tree/main/packages/graphics)
-  - [javascript](https://github.com/eng-dibo/dibo/tree/main/packages/javascript)
-  - [lazy-load](https://github.com/eng-dibo/dibo/tree/main/packages/lazy-load)
-  - [mongoose](https://github.com/eng-dibo/dibo/tree/main/packages/mongoose)
-  - [ngx-content-core](https://github.com/eng-dibo/dibo/tree/main/packages/ngx-content-core)
-  - [ngx-content-view-mat](https://github.com/eng-dibo/dibo/tree/main/packages/ngx-content-view-mat)
-  - [ngx-universal-express](https://github.com/eng-dibo/dibo/tree/main/packages/ngx-universal-express)
-  - [ngx-utils](https://github.com/eng-dibo/dibo/tree/main/packages/ngx-utils)
-  - [nodejs](https://github.com/eng-dibo/dibo/tree/main/packages/nodejs)
-  - [rxjs](https://github.com/eng-dibo/dibo/tree/main/packages/rxjs)
-  - [tmpl](https://github.com/eng-dibo/dibo/tree/main/packages/tmpl)
-  - [webpack](https://github.com/eng-dibo/dibo/tree/main/packages/webpack)