@xnestjs/storage 0.10.4 → 1.0.0

package/cjs/providers/s3-storage-connection.js

@@ -5,10 +5,12 @@ const tslib_1 = require("tslib");
 const Minio = tslib_1.__importStar(require("minio"));
 const storage_connection_js_1 = require("../services/storage-connection.js");
 class S3StorageConnection extends storage_connection_js_1.StorageConnection {
-    constructor(options) {
+    constructor(config) {
         super();
-        this._client = new Minio.Client(options);
-        this._client.setRequestOptions({ rejectUnauthorized: options.rejectUnauthorized });
+        this.provider = 's3';
+        this.config = config;
+        this._client = new Minio.Client(config);
+        this._client.setRequestOptions({ rejectUnauthorized: config.rejectUnauthorized });
     }
     async putObject(bucketName, objectName, source, options) {
         const meta = options ? updateMetadata(options?.metadata, options) : {};

package/cjs/storage-core.module.js

@@ -44,10 +44,11 @@ let StorageCoreModule = StorageCoreModule_1 = class StorageCoreModule {
         else {
             throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
         }
+        const storageToken = asyncOptions.token || storage_connection_js_1.StorageConnection;
         const providers = [
             optionsProvider,
             {
-                provide: asyncOptions.token || storage_connection_js_1.StorageConnection,
+                provide: storageToken,
                 inject: [storage_constants_js_1.STORAGE_OPTIONS],
                 useFactory: (options) => (0, storage_utils_js_1.createConnection)(options),
             },
@@ -57,7 +58,7 @@ let StorageCoreModule = StorageCoreModule_1 = class StorageCoreModule {
         return {
             module: StorageCoreModule_1,
             imports: asyncOptions.imports || [],
-            exports: asyncOptions.exports || [],
+            exports: [storageToken, ...(asyncOptions.exports || [])],
             providers,
             global: asyncOptions.global,
         };

package/cjs/storage.utils.js

@@ -3,13 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createConnection = createConnection;
 const s3_storage_connection_js_1 = require("./providers/s3-storage-connection.js");
 function createConnection(options) {
-    switch (options.type) {
-        case 's3': {
-            if (!options.s3)
-                throw new Error('You must provide S3 config');
-            return new s3_storage_connection_js_1.S3StorageConnection(options.s3);
-        }
-        default:
-            throw new Error(`Unknown Storage provider type ${options.type}`);
+    if (options.provider === 's3') {
+        if (!options.s3)
+            throw new Error('You must provide S3 config');
+        return new s3_storage_connection_js_1.S3StorageConnection(options.s3);
     }
+    throw new Error(`Unknown Storage provider (${options.provider})`);
 }

package/esm/providers/s3-storage-connection.js

@@ -1,10 +1,12 @@
 import * as Minio from 'minio';
 import { StorageConnection } from '../services/storage-connection.js';
 export class S3StorageConnection extends StorageConnection {
-    constructor(options) {
+    constructor(config) {
         super();
-        this._client = new Minio.Client(options);
-        this._client.setRequestOptions({ rejectUnauthorized: options.rejectUnauthorized });
+        this.provider = 's3';
+        this.config = config;
+        this._client = new Minio.Client(config);
+        this._client.setRequestOptions({ rejectUnauthorized: config.rejectUnauthorized });
     }
     async putObject(bucketName, objectName, source, options) {
         const meta = options ? updateMetadata(options?.metadata, options) : {};

package/esm/storage-core.module.js

@@ -41,10 +41,11 @@ let StorageCoreModule = StorageCoreModule_1 = class StorageCoreModule {
         else {
             throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
         }
+        const storageToken = asyncOptions.token || StorageConnection;
         const providers = [
             optionsProvider,
             {
-                provide: asyncOptions.token || StorageConnection,
+                provide: storageToken,
                 inject: [STORAGE_OPTIONS],
                 useFactory: (options) => createConnection(options),
             },
@@ -54,7 +55,7 @@ let StorageCoreModule = StorageCoreModule_1 = class StorageCoreModule {
         return {
             module: StorageCoreModule_1,
             imports: asyncOptions.imports || [],
-            exports: asyncOptions.exports || [],
+            exports: [storageToken, ...(asyncOptions.exports || [])],
             providers,
             global: asyncOptions.global,
         };

package/esm/storage.utils.js

@@ -1,12 +1,9 @@
 import { S3StorageConnection } from './providers/s3-storage-connection.js';
 export function createConnection(options) {
-    switch (options.type) {
-        case 's3': {
-            if (!options.s3)
-                throw new Error('You must provide S3 config');
-            return new S3StorageConnection(options.s3);
-        }
-        default:
-            throw new Error(`Unknown Storage provider type ${options.type}`);
+    if (options.provider === 's3') {
+        if (!options.s3)
+            throw new Error('You must provide S3 config');
+        return new S3StorageConnection(options.s3);
     }
+    throw new Error(`Unknown Storage provider (${options.provider})`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnestjs/storage",
-  "version": "0.10.4",
+  "version": "1.0.0",
   "description": "NestJS extension library for Storage solutions (S3,GS)",
   "author": "Panates",
   "license": "MIT",

package/types/interfaces/storage.interfaces.d.ts

@@ -4,13 +4,13 @@ import type * as minio from 'minio';
 export type S3Config = minio.ClientOptions & {
     rejectUnauthorized?: boolean;
 };
-export type AbstractType<T> = abstract new (...args: any[]) => T;
+export type StorageProvider = 's3' | 'gs';
 export interface S3StorageOptions {
-    type: 's3';
+    provider: StorageProvider;
     s3: S3Config;
 }
 export interface GSStorageOptions {
-    type: 'gs';
+    provider: StorageProvider;
     gs: {};
 }
 export type StorageOptions = S3StorageOptions | GSStorageOptions;
@@ -18,11 +18,11 @@ export type StorageModuleOptions = StorageOptions & {
     token?: InjectionToken;
     global?: boolean;
 };
-export interface StorageModuleAsyncOptions<I extends [any]> extends Pick<ModuleMetadata, 'imports' | 'exports' | 'providers'> {
+export interface StorageModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'exports' | 'providers'> {
     token?: InjectionToken;
-    inject?: I;
+    inject?: any[];
     global?: boolean;
     useClass?: Type<StorageOptions>;
     useExisting?: InjectionToken;
-    useFactory?: (...args: I) => Promise<StorageOptions> | StorageOptions;
+    useFactory?: (...args: any[]) => Promise<StorageOptions> | StorageOptions;
 }

package/types/providers/s3-storage-connection.d.ts

@@ -4,8 +4,10 @@ import { GetObjectSignedUrlOptions, ObjectInfo, PutObjectOptions } from '../inte
 import { S3Config } from '../interfaces/storage.interfaces.js';
 import { StorageConnection } from '../services/storage-connection.js';
 export declare class S3StorageConnection extends StorageConnection {
+    readonly provider = "s3";
+    readonly config: S3Config;
     private _client;
-    constructor(options: S3Config);
+    constructor(config: S3Config);
     putObject(bucketName: string, objectName: string, source: Buffer | Readable | string, options?: PutObjectOptions): Promise<void>;
     getObjectInfo(bucketName: string, objectName: string): Promise<ObjectInfo>;
     removeObject(bucketName: string, objectName: string): Promise<void>;

package/types/services/storage-connection.d.ts

@@ -1,8 +1,11 @@
 import type { Buffer } from 'buffer';
 import type { Readable } from 'stream';
 import type { GetObjectSignedUrlOptions, ObjectInfo, PutObjectOptions } from '../interfaces/connection.interfaces.js';
+import type { StorageProvider } from '../interfaces/storage.interfaces.js';
 import { StorageBucket } from './storage-bucket.js';
 export declare abstract class StorageConnection {
+    abstract readonly provider: StorageProvider;
+    abstract readonly config: any;
     getBucket(bucketName: string): StorageBucket;
     abstract putObject(bucketName: string, objectName: string, buffer: Buffer, options?: PutObjectOptions): Promise<void>;
     abstract putObject(bucketName: string, objectName: string, stream: Readable, options?: PutObjectOptions): Promise<void>;

package/types/storage-core.module.d.ts

@@ -2,5 +2,5 @@ import { DynamicModule } from '@nestjs/common';
 import { StorageModuleAsyncOptions, StorageModuleOptions } from './interfaces/storage.interfaces.js';
 export declare class StorageCoreModule {
     static register(options: StorageModuleOptions): DynamicModule;
-    static registerAsync<I extends [any] = never>(asyncOptions: StorageModuleAsyncOptions<I>): DynamicModule;
+    static registerAsync(asyncOptions: StorageModuleAsyncOptions): DynamicModule;
 }

package/types/storage.module.d.ts

@@ -2,5 +2,5 @@ import { DynamicModule } from '@nestjs/common';
 import { StorageModuleAsyncOptions, StorageModuleOptions } from './interfaces/storage.interfaces.js';
 export declare class StorageModule {
     static register(options: StorageModuleOptions): DynamicModule;
-    static registerAsync<I extends [any] = never>(options: StorageModuleAsyncOptions<I>): DynamicModule;
+    static registerAsync(options: StorageModuleAsyncOptions): DynamicModule;
 }

package/types/storage.utils.d.ts

@@ -1,3 +1,3 @@
-import { StorageModuleOptions } from './interfaces/storage.interfaces.js';
+import { StorageOptions } from './interfaces/storage.interfaces.js';
 import { StorageConnection } from './services/storage-connection.js';
-export declare function createConnection(options: StorageModuleOptions): StorageConnection;
+export declare function createConnection(options: StorageOptions): StorageConnection;