@rytass/storages-adapter-gcs 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Rytass Co. Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# Rytass Utils - File Storages (Google Cloud Storage)
+
+## Features
+
+- [x] Google Cloud Storage bucket

package/index.cjs.js

@@ -0,0 +1,110 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var storages = require('@rytass/storages');
+var stream = require('stream');
+var uuid = require('uuid');
+var storage = require('@google-cloud/storage');
+
+class StorageGCSService extends storages.Storage {
+    constructor(options){
+        super(options);
+        this.storage = new storage.Storage({
+            projectId: options.projectId,
+            credentials: options.credentials
+        });
+        this.bucket = this.storage.bucket(options.bucket);
+    }
+    async url(key, expires = 1000 * 60 * 60 * 24) {
+        const file = this.bucket.file(key);
+        const [url] = await file.getSignedUrl({
+            action: 'read',
+            expires
+        });
+        return url;
+    }
+    async read(key, options) {
+        const file = this.bucket.file(key);
+        try {
+            if (options?.format === 'buffer') {
+                const [buffer] = await file.download();
+                return buffer;
+            }
+            return file.createReadStream();
+        } catch (ex) {
+            if (/No such object/.test(ex.message)) {
+                throw new storages.StorageError(storages.ErrorCode.READ_FILE_ERROR, 'File not found');
+            }
+            throw ex;
+        }
+    }
+    async writeStreamFile(stream$1, options) {
+        const givenFilename = options?.filename;
+        if (givenFilename) {
+            const file = this.bucket.file(givenFilename);
+            const writeStream = file.createWriteStream({
+                gzip: 'auto',
+                ...options?.contentType ? {
+                    contentType: options?.contentType
+                } : {}
+            });
+            stream$1.pipe(writeStream);
+            return new Promise((resolve)=>{
+                writeStream.on('finish', ()=>{
+                    resolve({
+                        key: givenFilename
+                    });
+                });
+            });
+        }
+        const tempFilename = uuid.v4();
+        const uploadStream = new stream.PassThrough();
+        const getFilenamePromise = this.getStreamFilename(stream$1);
+        const tempFile = this.bucket.file(tempFilename);
+        const writeStream1 = tempFile.createWriteStream({
+            gzip: 'auto',
+            ...options?.contentType ? {
+                contentType: options?.contentType
+            } : {}
+        });
+        stream$1.pipe(uploadStream).pipe(writeStream1);
+        const [filename] = await Promise.all([
+            getFilenamePromise,
+            new Promise((resolve)=>{
+                writeStream1.on('finish', resolve);
+            }), 
+        ]);
+        await tempFile.move(filename);
+        return {
+            key: filename
+        };
+    }
+    async writeBufferFile(buffer, options) {
+        const filename = options?.filename || await this.getBufferFilename(buffer);
+        const file = this.bucket.file(filename);
+        await file.save(buffer, {
+            gzip: 'auto',
+            ...options?.contentType ? {
+                contentType: options?.contentType
+            } : {}
+        });
+        return {
+            key: filename
+        };
+    }
+    write(file, options) {
+        if (file instanceof Buffer) {
+            return this.writeBufferFile(file, options);
+        }
+        return this.writeStreamFile(file, options);
+    }
+    batchWrite(files) {
+        return Promise.all(files.map((file)=>this.write(file)));
+    }
+    async remove(key) {
+        await this.bucket.file(key).delete();
+    }
+}
+
+exports.StorageGCSService = StorageGCSService;

package/index.d.ts

@@ -0,0 +1 @@
+export * from './storages-adapter-gcs';

package/index.js

@@ -0,0 +1 @@
+export { StorageGCSService } from './storages-adapter-gcs.js';

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@rytass/storages-adapter-gcs",
+  "version": "0.1.1",
+  "description": "Google Cloud Storage Adapter for @rytass/storages",
+  "keywords": [
+    "gcp",
+    "cloud",
+    "storage",
+    "rytass",
+    "storage",
+    "gcs"
+  ],
+  "author": "Chia Yu Pai <fantasyatelier@gmail.com>",
+  "homepage": "https://github.com/Rytass/Utils#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rytass/Utils.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rytass/Utils/issues"
+  },
+  "dependencies": {
+    "@google-cloud/storage": "^6.5.3",
+    "@rytass/storages": "^0.1.2",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@types/uuid": "^8.3.4"
+  },
+  "main": "./index.cjs.js",
+  "module": "./index.js",
+  "typings": "./index.d.ts"
+}

package/storages-adapter-gcs.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Storage, ReadBufferFileOptions, ReadStreamFileOptions, InputFile, StorageFile, WriteFileOptions } from '@rytass/storages';
+import { Readable } from 'stream';
+import { GCSOptions } from './typings';
+export declare class StorageGCSService extends Storage<GCSOptions> {
+    private readonly storage;
+    private readonly bucket;
+    constructor(options: GCSOptions);
+    url(key: string, expires?: number): Promise<string>;
+    read(key: string): Promise<Readable>;
+    read(key: string, options: ReadBufferFileOptions): Promise<Buffer>;
+    read(key: string, options: ReadStreamFileOptions): Promise<Readable>;
+    private writeStreamFile;
+    private writeBufferFile;
+    write(file: InputFile, options?: WriteFileOptions): Promise<StorageFile>;
+    batchWrite(files: InputFile[]): Promise<StorageFile[]>;
+    remove(key: string): Promise<void>;
+}

package/storages-adapter-gcs.js

@@ -0,0 +1,106 @@
+import { Storage, StorageError, ErrorCode } from '@rytass/storages';
+import { PassThrough } from 'stream';
+import { v4 } from 'uuid';
+import { Storage as Storage$1 } from '@google-cloud/storage';
+
+class StorageGCSService extends Storage {
+    constructor(options){
+        super(options);
+        this.storage = new Storage$1({
+            projectId: options.projectId,
+            credentials: options.credentials
+        });
+        this.bucket = this.storage.bucket(options.bucket);
+    }
+    async url(key, expires = 1000 * 60 * 60 * 24) {
+        const file = this.bucket.file(key);
+        const [url] = await file.getSignedUrl({
+            action: 'read',
+            expires
+        });
+        return url;
+    }
+    async read(key, options) {
+        const file = this.bucket.file(key);
+        try {
+            if (options?.format === 'buffer') {
+                const [buffer] = await file.download();
+                return buffer;
+            }
+            return file.createReadStream();
+        } catch (ex) {
+            if (/No such object/.test(ex.message)) {
+                throw new StorageError(ErrorCode.READ_FILE_ERROR, 'File not found');
+            }
+            throw ex;
+        }
+    }
+    async writeStreamFile(stream, options) {
+        const givenFilename = options?.filename;
+        if (givenFilename) {
+            const file = this.bucket.file(givenFilename);
+            const writeStream = file.createWriteStream({
+                gzip: 'auto',
+                ...options?.contentType ? {
+                    contentType: options?.contentType
+                } : {}
+            });
+            stream.pipe(writeStream);
+            return new Promise((resolve)=>{
+                writeStream.on('finish', ()=>{
+                    resolve({
+                        key: givenFilename
+                    });
+                });
+            });
+        }
+        const tempFilename = v4();
+        const uploadStream = new PassThrough();
+        const getFilenamePromise = this.getStreamFilename(stream);
+        const tempFile = this.bucket.file(tempFilename);
+        const writeStream1 = tempFile.createWriteStream({
+            gzip: 'auto',
+            ...options?.contentType ? {
+                contentType: options?.contentType
+            } : {}
+        });
+        stream.pipe(uploadStream).pipe(writeStream1);
+        const [filename] = await Promise.all([
+            getFilenamePromise,
+            new Promise((resolve)=>{
+                writeStream1.on('finish', resolve);
+            }), 
+        ]);
+        await tempFile.move(filename);
+        return {
+            key: filename
+        };
+    }
+    async writeBufferFile(buffer, options) {
+        const filename = options?.filename || await this.getBufferFilename(buffer);
+        const file = this.bucket.file(filename);
+        await file.save(buffer, {
+            gzip: 'auto',
+            ...options?.contentType ? {
+                contentType: options?.contentType
+            } : {}
+        });
+        return {
+            key: filename
+        };
+    }
+    write(file, options) {
+        if (file instanceof Buffer) {
+            return this.writeBufferFile(file, options);
+        }
+        return this.writeStreamFile(file, options);
+    }
+    batchWrite(files) {
+        return Promise.all(files.map((file)=>this.write(file)));
+    }
+    async remove(key) {
+        await this.bucket.file(key).delete();
+    }
+}
+
+export { StorageGCSService };

package/typings.d.ts

@@ -0,0 +1,9 @@
+import { StorageOptions } from '@rytass/storages';
+export interface GCSOptions extends StorageOptions {
+    bucket: string;
+    projectId: string;
+    credentials: {
+        client_email: string;
+        private_key: string;
+    };
+}