nestjs-minio-s3 1.0.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+RELEASE 1.0.0

package/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+# Contributing
+
+1. [Fork it](https://help.github.com/articles/fork-a-repo/)
+2. Install dependencies (`npm install`)
+3. Create your feature branch (`git checkout -b my-new-feature`)
+4. Commit your changes (`git commit -am 'Added some feature'`)
+5. Test your changes (`npm test`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. [Create new Pull Request](https://help.github.com/articles/creating-a-pull-request/)
+
+## Testing
+
+We use [Jest](https://github.com/facebook/jest) to write tests. Run our test suite with this command:
+
+```
+npm test
+```
+
+## Code Style
+
+We use [Prettier](https://prettier.io/) and tslint to maintain code style and best practices.
+Please make sure your PR adheres to the guides by running:
+
+```
+npm run format
+```
+
+and
+```
+npm run lint
+```

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 John Biundo
+
+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,37 @@
+<h1 align="center"></h1>
+
+<div align="center">
+  <a href="http://nestjs.com/" target="_blank">
+    <img src="https://nestjs.com/img/logo_text.svg" width="150" alt="Nest Logo" />
+  </a>
+</div>
+
+<h3 align="center">NestJS npm Package Minio S3</h3>
+
+<div align="center">
+  <a href="https://nestjs.com" target="_blank">
+    <img src="https://img.shields.io/badge/built%20with-NestJs-red.svg" alt="Built with NestJS">
+  </a>
+</div>
+
+### Installation
+
+```bash
+npm install nestjs-minio-s3
+```
+
+## Change Log
+
+See [Changelog](CHANGELOG.md) for more information.
+
+## Contributing
+
+Contributions welcome! See [Contributing](CONTRIBUTING.md).
+
+## Author
+
+**Artem Kosyrev**
+
+## License
+
+Licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const MINIO_MODULE_OPTIONS = "MINIO_MODULE_OPTIONS";

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINIO_MODULE_OPTIONS = void 0;
+exports.MINIO_MODULE_OPTIONS = 'MINIO_MODULE_OPTIONS';

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './minio.service';
+export * from './minio.module';
+export * from './interfaces/minio-options.interface';
+export * from './interfaces/minio-bucket-config.interface';
+export * from './constants';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./minio.service"), exports);
+__exportStar(require("./minio.module"), exports);
+__exportStar(require("./interfaces/minio-options.interface"), exports);
+__exportStar(require("./interfaces/minio-bucket-config.interface"), exports);
+__exportStar(require("./constants"), exports);

package/dist/interfaces/minio-bucket-config.interface.d.ts

@@ -0,0 +1,13 @@
+export interface MinioBucketConfig {
+    name: string;
+    policy?: 'public' | 'private' | 'custom';
+    customPolicy?: any;
+}
+export interface MinioBucketConfigPolicyStatement {
+    Effect: 'Allow' | 'Deny';
+    Principal: {
+        AWS: string[];
+    };
+    Action: string[];
+    Resource: string[];
+}

package/dist/interfaces/minio-bucket-config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/minio-options.interface.d.ts

@@ -0,0 +1,21 @@
+import { MinioBucketConfig } from './minio-bucket-config.interface';
+import { Type } from '@nestjs/common';
+import { ModuleMetadata } from '@nestjs/common/interfaces/modules/module-metadata.interface';
+export interface MinioModuleOptions {
+    endpoint: string;
+    port?: number;
+    useSSL?: boolean;
+    accessKey: string;
+    secretKey: string;
+    region?: string;
+    buckets?: MinioBucketConfig[];
+}
+export interface MinioOptionsFactory {
+    createMinioOptions(): Promise<MinioModuleOptions> | MinioModuleOptions;
+}
+export interface MinioModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<MinioOptionsFactory>;
+    useClass?: Type<MinioOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<MinioModuleOptions> | MinioModuleOptions;
+    inject?: any[];
+}

package/dist/interfaces/minio-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/minio.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { MinioModuleAsyncOptions, MinioModuleOptions } from './interfaces/minio-options.interface';
+export declare class MinioModule {
+    static forRoot(options: MinioModuleOptions): DynamicModule;
+    static forRootAsync(options: MinioModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

package/dist/minio.module.js

@@ -0,0 +1,76 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var MinioModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinioModule = void 0;
+const common_1 = require("@nestjs/common");
+const minio_service_1 = require("./minio.service");
+const constants_1 = require("./constants");
+let MinioModule = MinioModule_1 = class MinioModule {
+    static forRoot(options) {
+        return {
+            module: MinioModule_1,
+            providers: [
+                {
+                    provide: constants_1.MINIO_MODULE_OPTIONS,
+                    useValue: options,
+                },
+                minio_service_1.MinioService,
+            ],
+            exports: [minio_service_1.MinioService],
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: MinioModule_1,
+            imports: options.imports || [],
+            providers: [...this.createAsyncProviders(options), minio_service_1.MinioService],
+            exports: [minio_service_1.MinioService],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: constants_1.MINIO_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: constants_1.MINIO_MODULE_OPTIONS,
+            useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () { return yield optionsFactory.createMinioOptions(); }),
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+};
+exports.MinioModule = MinioModule;
+exports.MinioModule = MinioModule = MinioModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], MinioModule);

package/dist/minio.service.d.ts

@@ -0,0 +1,20 @@
+import { OnModuleInit } from '@nestjs/common';
+import { S3Client } from '@aws-sdk/client-s3';
+import { MinioModuleOptions } from './interfaces/minio-options.interface';
+export declare class MinioService implements OnModuleInit {
+    private readonly options;
+    private readonly logger;
+    private s3Client;
+    constructor(options: MinioModuleOptions);
+    onModuleInit(): Promise<void>;
+    private initializeBuckets;
+    private createBucketIfNotExists;
+    private setBucketPolicy;
+    upload(bucketName: string, key: string, body: Buffer, contentType?: string): Promise<string>;
+    delete(bucketName: string, key: string): Promise<void>;
+    get(bucketName: string, key: string): Promise<Buffer>;
+    list(bucketName: string, prefix?: string): Promise<string[]>;
+    getPublicUrl(bucketName: string, key: string): string;
+    getKeyFromUrl(url: string, bucketName: string): string | null;
+    getClient(): S3Client;
+}

package/dist/minio.service.js

@@ -0,0 +1,198 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var MinioService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinioService = void 0;
+const common_1 = require("@nestjs/common");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const constants_1 = require("./constants");
+let MinioService = MinioService_1 = class MinioService {
+    constructor(options) {
+        this.options = options;
+        this.logger = new common_1.Logger(MinioService_1.name);
+        this.s3Client = new client_s3_1.S3Client({
+            endpoint: this.options.endpoint,
+            region: this.options.region || 'us-east-1',
+            credentials: {
+                accessKeyId: this.options.accessKey,
+                secretAccessKey: this.options.secretKey,
+            },
+            forcePathStyle: true,
+        });
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.options.buckets && this.options.buckets.length > 0) {
+                yield this.initializeBuckets(this.options.buckets);
+            }
+        });
+    }
+    initializeBuckets(buckets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const bucket of buckets) {
+                yield this.createBucketIfNotExists(bucket.name);
+                yield this.setBucketPolicy(bucket);
+            }
+        });
+    }
+    createBucketIfNotExists(bucketName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.s3Client.send(new client_s3_1.HeadBucketCommand({ Bucket: bucketName }));
+                this.logger.log(`Bucket "${bucketName}" already exists`);
+            }
+            catch (err) {
+                if (err.name === 'NotFound') {
+                    try {
+                        yield this.s3Client.send(new client_s3_1.CreateBucketCommand({ Bucket: bucketName }));
+                        this.logger.log(`Bucket "${bucketName}" created successfully`);
+                    }
+                    catch (createErr) {
+                        this.logger.error(`Error creating bucket "${bucketName}":`, createErr);
+                        throw createErr;
+                    }
+                }
+                else {
+                    this.logger.error(`Error checking bucket "${bucketName}":`, err);
+                    throw err;
+                }
+            }
+        });
+    }
+    setBucketPolicy(bucketConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let policy;
+            if (bucketConfig.customPolicy) {
+                policy = bucketConfig.customPolicy;
+            }
+            else if (bucketConfig.policy === 'public') {
+                policy = {
+                    Version: '2012-10-17',
+                    Statement: [
+                        {
+                            Effect: 'Allow',
+                            Principal: { AWS: ['*'] },
+                            Action: ['s3:GetObject'],
+                            Resource: [`arn:aws:s3:::${bucketConfig.name}/*`],
+                        },
+                    ],
+                };
+            }
+            else if (bucketConfig.policy === 'private') {
+                return;
+            }
+            if (policy) {
+                try {
+                    yield this.s3Client.send(new client_s3_1.PutBucketPolicyCommand({
+                        Bucket: bucketConfig.name,
+                        Policy: JSON.stringify(policy),
+                    }));
+                    this.logger.log(`Policy set for bucket "${bucketConfig.name}"`);
+                }
+                catch (err) {
+                    this.logger.error(`Error setting policy for bucket "${bucketConfig.name}":`, err);
+                }
+            }
+        });
+    }
+    upload(bucketName, key, body, contentType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.s3Client.send(new client_s3_1.PutObjectCommand({
+                    Bucket: bucketName,
+                    Key: key,
+                    Body: body,
+                    ContentType: contentType,
+                }));
+                return this.getPublicUrl(bucketName, key);
+            }
+            catch (err) {
+                this.logger.error(`Error uploading file to ${bucketName}/${key}: `, err);
+                throw err;
+            }
+        });
+    }
+    delete(bucketName, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.s3Client.send(new client_s3_1.DeleteObjectCommand({
+                    Bucket: bucketName,
+                    Key: key,
+                }));
+                this.logger.log(`Deleted ${bucketName}/${key}`);
+            }
+            catch (err) {
+                this.logger.error(`Error deleting file ${bucketName}/${key}: `, err);
+                throw err;
+            }
+        });
+    }
+    get(bucketName, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.s3Client.send(new client_s3_1.GetObjectCommand({
+                    Bucket: bucketName,
+                    Key: key,
+                }));
+                return Buffer.from(yield response.Body.transformToByteArray());
+            }
+            catch (err) {
+                this.logger.error(`Error getting file ${bucketName}/${key}: `, err);
+                throw err;
+            }
+        });
+    }
+    list(bucketName, prefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.s3Client.send(new client_s3_1.ListObjectsV2Command({
+                    Bucket: bucketName,
+                    Prefix: prefix,
+                }));
+                return response.Contents.map((item) => item.Key) || [];
+            }
+            catch (err) {
+                this.logger.error(`Error listing files in ${bucketName}: `, err);
+                throw err;
+            }
+        });
+    }
+    getPublicUrl(bucketName, key) {
+        const url = new URL(this.options.endpoint);
+        url.pathname = `/${bucketName}/${key}`;
+        return url.toString();
+    }
+    getKeyFromUrl(url, bucketName) {
+        const parts = url.split(`/${bucketName}/`);
+        return parts.length > 1 ? parts[1] : null;
+    }
+    getClient() {
+        return this.s3Client;
+    }
+};
+exports.MinioService = MinioService;
+exports.MinioService = MinioService = MinioService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_1.MINIO_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], MinioService);

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "nestjs-minio-s3",
+  "version": "1.0.0",
+  "description": "NestJS npm package starter",
+  "author": "Artem Kosyrev <cosinusgradusov90@gmail.com>",
+  "license": "MIT",
+  "readmeFilename": "README.md",
+  "main": "dist/index.js",
+  "files": [
+    "dist/**/*",
+    "*.md"
+  ],
+  "scripts": {
+    "start:dev": "tsc -w",
+    "build": "tsc",
+    "prepare": "npm run build",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "tslint -p tsconfig.json -c tslint.json",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:e2e": "jest --config ./test/jest-e2e.json"
+  },
+  "keywords": [
+    "nestjs"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CurlyBattery/nestjs-minio-s3-repo"
+  },
+  "bugs": "https://github.com/CurlyBattery/nestjs-minio-s3-repo",
+  "peerDependencies": {
+    "@nestjs/common": "^6.0.0"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.958.0",
+    "rxjs": "^7.8.2"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^6.11.11",
+    "@nestjs/core": "^6.0.0",
+    "@nestjs/platform-express": "^6.0.0",
+    "@nestjs/testing": "6.1.1",
+    "@types/express": "4.16.1",
+    "@types/jest": "24.0.11",
+    "@types/node": "^25.0.3",
+    "@types/supertest": "2.0.7",
+    "jest": "24.7.1",
+    "prettier": "1.17.0",
+    "supertest": "4.0.2",
+    "ts-jest": "24.0.2",
+    "ts-node": "8.1.0",
+    "tsc-watch": "2.2.1",
+    "tsconfig-paths": "3.8.0",
+    "tslint": "5.16.0",
+    "typescript": "^5.9.3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".spec.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}