@xnestjs/storage 0.10.0 → 1.0.0

package/cjs/index.js

@@ -6,5 +6,4 @@ tslib_1.__exportStar(require("./interfaces/storage.interfaces.js"), exports);
 tslib_1.__exportStar(require("./services/storage-bucket.js"), exports);
 tslib_1.__exportStar(require("./services/storage-connection.js"), exports);
 tslib_1.__exportStar(require("./storage.constants.js"), exports);
-tslib_1.__exportStar(require("./storage.decorators.js"), exports);
 tslib_1.__exportStar(require("./storage.module.js"), exports);

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

@@ -5,11 +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);
-        // todo: remove casting to any later. https://github.com/minio/minio-js/issues/1163
-        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

@@ -4,61 +4,63 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageCoreModule = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
+const storage_connection_js_1 = require("./services/storage-connection.js");
+const storage_constants_js_1 = require("./storage.constants.js");
 const storage_utils_js_1 = require("./storage.utils.js");
 let StorageCoreModule = StorageCoreModule_1 = class StorageCoreModule {
     static register(options) {
         const connectionProvider = {
-            provide: (0, storage_utils_js_1.getStorageConnectionToken)(options.name),
+            provide: options.token || storage_connection_js_1.StorageConnection,
             useValue: (0, storage_utils_js_1.createConnection)(options),
         };
         return {
             module: StorageCoreModule_1,
             providers: [connectionProvider],
             exports: [connectionProvider],
+            global: options.global,
         };
     }
-    static forRootAsync(asyncOptions) {
-        const providers = [...this.createAsyncProviders(asyncOptions), ...(asyncOptions.extraProviders || [])];
-        return {
-            module: StorageCoreModule_1,
-            imports: asyncOptions.imports || [],
-            providers,
-            exports: providers,
-        };
-    }
-    static createAsyncProviders(asyncOptions) {
-        if (asyncOptions.useFactory || asyncOptions.useExisting)
-            return [this.createAsyncOptionsProvider(asyncOptions)];
-        if (asyncOptions.useClass) {
-            return [
-                this.createAsyncOptionsProvider(asyncOptions),
-                { provide: asyncOptions.useClass, useClass: asyncOptions.useClass },
-            ];
-        }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
-    }
-    static createAsyncOptionsProvider(asyncOptions) {
+    static registerAsync(asyncOptions) {
+        let optionsProvider;
         if (asyncOptions.useFactory) {
-            return {
-                provide: (0, storage_utils_js_1.getStorageConnectionToken)(asyncOptions.name),
-                useFactory: this.createFactoryWrapper(asyncOptions.useFactory),
+            optionsProvider = {
+                provide: storage_constants_js_1.STORAGE_OPTIONS,
                 inject: asyncOptions.inject || [],
+                useFactory: asyncOptions.useFactory,
             };
         }
-        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
-        if (useClass) {
-            return {
-                provide: (0, storage_utils_js_1.getStorageConnectionToken)(asyncOptions.name),
-                useFactory: this.createFactoryWrapper((optionsFactory) => optionsFactory.getOptions()),
-                inject: [useClass],
+        else if (asyncOptions.useExisting) {
+            optionsProvider = {
+                provide: storage_constants_js_1.STORAGE_OPTIONS,
+                useExisting: asyncOptions.useExisting,
             };
         }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
-    }
-    static createFactoryWrapper(useFactory) {
-        return async (...args) => {
-            const clientOptions = await useFactory(...args);
-            return (0, storage_utils_js_1.createConnection)(clientOptions);
+        else if (asyncOptions.useClass) {
+            optionsProvider = {
+                provide: storage_constants_js_1.STORAGE_OPTIONS,
+                useClass: asyncOptions.useClass,
+            };
+        }
+        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: storageToken,
+                inject: [storage_constants_js_1.STORAGE_OPTIONS],
+                useFactory: (options) => (0, storage_utils_js_1.createConnection)(options),
+            },
+        ];
+        if (asyncOptions.providers)
+            providers.push(...asyncOptions.providers);
+        return {
+            module: StorageCoreModule_1,
+            imports: asyncOptions.imports || [],
+            exports: [storageToken, ...(asyncOptions.exports || [])],
+            providers,
+            global: asyncOptions.global,
         };
     }
 };

package/cjs/storage.constants.js

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

package/cjs/storage.module.js

@@ -10,12 +10,14 @@ let StorageModule = StorageModule_1 = class StorageModule {
         return {
             module: StorageModule_1,
             imports: [storage_core_module_js_1.StorageCoreModule.register(options)],
+            global: options.global,
         };
     }
     static registerAsync(options) {
         return {
             module: StorageModule_1,
-            imports: [storage_core_module_js_1.StorageCoreModule.forRootAsync(options)],
+            imports: [storage_core_module_js_1.StorageCoreModule.registerAsync(options)],
+            global: options.global,
         };
     }
 };

package/cjs/storage.utils.js

@@ -1,24 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStorageConnectionToken = getStorageConnectionToken;
 exports.createConnection = createConnection;
 const s3_storage_connection_js_1 = require("./providers/s3-storage-connection.js");
-const storage_connection_js_1 = require("./services/storage-connection.js");
-function getStorageConnectionToken(name) {
-    if (!name)
-        return storage_connection_js_1.StorageConnection;
-    // noinspection SuspiciousTypeOfGuard
-    if (typeof name === 'symbol' || typeof name === 'function')
-        return name;
-    return `${name}_StorageConnection`;
-}
 function createConnection(options) {
-    if (!options.config)
-        throw new Error('You must provide storage config');
-    switch (options.type) {
-        case 's3':
-            return new s3_storage_connection_js_1.S3StorageConnection(options.config);
-        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/index.js

@@ -3,5 +3,4 @@ export * from './interfaces/storage.interfaces.js';
 export * from './services/storage-bucket.js';
 export * from './services/storage-connection.js';
 export * from './storage.constants.js';
-export * from './storage.decorators.js';
 export * from './storage.module.js';

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

@@ -1,11 +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);
-        // todo: remove casting to any later. https://github.com/minio/minio-js/issues/1163
-        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

@@ -1,61 +1,63 @@
 var StorageCoreModule_1;
 import { __decorate } from "tslib";
 import { Global, Module } from '@nestjs/common';
-import { createConnection, getStorageConnectionToken } from './storage.utils.js';
+import { StorageConnection } from './services/storage-connection.js';
+import { STORAGE_OPTIONS } from './storage.constants.js';
+import { createConnection } from './storage.utils.js';
 let StorageCoreModule = StorageCoreModule_1 = class StorageCoreModule {
     static register(options) {
         const connectionProvider = {
-            provide: getStorageConnectionToken(options.name),
+            provide: options.token || StorageConnection,
             useValue: createConnection(options),
         };
         return {
             module: StorageCoreModule_1,
             providers: [connectionProvider],
             exports: [connectionProvider],
+            global: options.global,
         };
     }
-    static forRootAsync(asyncOptions) {
-        const providers = [...this.createAsyncProviders(asyncOptions), ...(asyncOptions.extraProviders || [])];
-        return {
-            module: StorageCoreModule_1,
-            imports: asyncOptions.imports || [],
-            providers,
-            exports: providers,
-        };
-    }
-    static createAsyncProviders(asyncOptions) {
-        if (asyncOptions.useFactory || asyncOptions.useExisting)
-            return [this.createAsyncOptionsProvider(asyncOptions)];
-        if (asyncOptions.useClass) {
-            return [
-                this.createAsyncOptionsProvider(asyncOptions),
-                { provide: asyncOptions.useClass, useClass: asyncOptions.useClass },
-            ];
-        }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
-    }
-    static createAsyncOptionsProvider(asyncOptions) {
+    static registerAsync(asyncOptions) {
+        let optionsProvider;
         if (asyncOptions.useFactory) {
-            return {
-                provide: getStorageConnectionToken(asyncOptions.name),
-                useFactory: this.createFactoryWrapper(asyncOptions.useFactory),
+            optionsProvider = {
+                provide: STORAGE_OPTIONS,
                 inject: asyncOptions.inject || [],
+                useFactory: asyncOptions.useFactory,
             };
         }
-        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
-        if (useClass) {
-            return {
-                provide: getStorageConnectionToken(asyncOptions.name),
-                useFactory: this.createFactoryWrapper((optionsFactory) => optionsFactory.getOptions()),
-                inject: [useClass],
+        else if (asyncOptions.useExisting) {
+            optionsProvider = {
+                provide: STORAGE_OPTIONS,
+                useExisting: asyncOptions.useExisting,
             };
         }
-        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
-    }
-    static createFactoryWrapper(useFactory) {
-        return async (...args) => {
-            const clientOptions = await useFactory(...args);
-            return createConnection(clientOptions);
+        else if (asyncOptions.useClass) {
+            optionsProvider = {
+                provide: STORAGE_OPTIONS,
+                useClass: asyncOptions.useClass,
+            };
+        }
+        else {
+            throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+        }
+        const storageToken = asyncOptions.token || StorageConnection;
+        const providers = [
+            optionsProvider,
+            {
+                provide: storageToken,
+                inject: [STORAGE_OPTIONS],
+                useFactory: (options) => createConnection(options),
+            },
+        ];
+        if (asyncOptions.providers)
+            providers.push(...asyncOptions.providers);
+        return {
+            module: StorageCoreModule_1,
+            imports: asyncOptions.imports || [],
+            exports: [storageToken, ...(asyncOptions.exports || [])],
+            providers,
+            global: asyncOptions.global,
         };
     }
 };

package/esm/storage.constants.js

@@ -1 +1 @@
-export const STORAGE_MODULE_TOKEN = Symbol('STORAGE_MODULE_ID');
+export const STORAGE_OPTIONS = Symbol('STORAGE_OPTIONS');

package/esm/storage.module.js

@@ -7,12 +7,14 @@ let StorageModule = StorageModule_1 = class StorageModule {
         return {
             module: StorageModule_1,
             imports: [StorageCoreModule.register(options)],
+            global: options.global,
         };
     }
     static registerAsync(options) {
         return {
             module: StorageModule_1,
-            imports: [StorageCoreModule.forRootAsync(options)],
+            imports: [StorageCoreModule.registerAsync(options)],
+            global: options.global,
         };
     }
 };

package/esm/storage.utils.js

@@ -1,20 +1,9 @@
 import { S3StorageConnection } from './providers/s3-storage-connection.js';
-import { StorageConnection } from './services/storage-connection.js';
-export function getStorageConnectionToken(name) {
-    if (!name)
-        return StorageConnection;
-    // noinspection SuspiciousTypeOfGuard
-    if (typeof name === 'symbol' || typeof name === 'function')
-        return name;
-    return `${name}_StorageConnection`;
-}
 export function createConnection(options) {
-    if (!options.config)
-        throw new Error('You must provide storage config');
-    switch (options.type) {
-        case 's3':
-            return new S3StorageConnection(options.config);
-        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,14 +1,14 @@
 {
   "name": "@xnestjs/storage",
-  "version": "0.10.0",
+  "version": "1.0.0",
   "description": "NestJS extension library for Storage solutions (S3,GS)",
   "author": "Panates",
   "license": "MIT",
   "peerDependencies": {
-    "@nestjs/common": "^10.4.1"
+    "@nestjs/common": "^10.4.7"
   },
   "optionalDependencies": {
-    "minio": "^8.0.1"
+    "minio": "^8.0.2"
   },
   "type": "module",
   "exports": {
@@ -37,7 +37,6 @@
     "npm": ">=7.0.0"
   },
   "files": [
-    "bin/",
     "cjs/",
     "esm/",
     "types/",

package/types/index.d.cts

@@ -3,5 +3,4 @@ export * from './interfaces/storage.interfaces.js';
 export * from './services/storage-bucket.js';
 export * from './services/storage-connection.js';
 export * from './storage.constants.js';
-export * from './storage.decorators.js';
 export * from './storage.module.js';

package/types/index.d.ts

@@ -3,5 +3,4 @@ export * from './interfaces/storage.interfaces.js';
 export * from './services/storage-bucket.js';
 export * from './services/storage-connection.js';
 export * from './storage.constants.js';
-export * from './storage.decorators.js';
 export * from './storage.module.js';

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

@@ -1,25 +1,28 @@
-import { Provider } from '@nestjs/common';
-import { ModuleMetadata, Type } from '@nestjs/common/interfaces';
-import * as minio from 'minio';
-export type S3StorageOptions = minio.ClientOptions & {
-    rejectUnauthorized: boolean;
+import type { InjectionToken } from '@nestjs/common';
+import type { ModuleMetadata, Type } from '@nestjs/common/interfaces';
+import type * as minio from 'minio';
+export type S3Config = minio.ClientOptions & {
+    rejectUnauthorized?: boolean;
 };
-export type AbstractType<T> = abstract new (...args: any[]) => T;
-export interface StorageOptions {
-    type: 's3' | 'gs';
-    config: S3StorageOptions;
+export type StorageProvider = 's3' | 'gs';
+export interface S3StorageOptions {
+    provider: StorageProvider;
+    s3: S3Config;
 }
+export interface GSStorageOptions {
+    provider: StorageProvider;
+    gs: {};
+}
+export type StorageOptions = S3StorageOptions | GSStorageOptions;
 export type StorageModuleOptions = StorageOptions & {
-    name?: string;
+    token?: InjectionToken;
+    global?: boolean;
 };
-export interface StorageModuleOptionsFactory {
-    getOptions(): Promise<StorageOptions> | StorageOptions;
-}
-export interface StorageModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    name?: string;
+export interface StorageModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'exports' | 'providers'> {
+    token?: InjectionToken;
     inject?: any[];
-    useClass?: Type<StorageModuleOptionsFactory>;
-    useExisting?: Type<StorageModuleOptionsFactory>;
-    useFactory?: (...args: any[]) => Promise<StorageModuleOptions> | StorageModuleOptions;
-    extraProviders?: Provider[];
+    global?: boolean;
+    useClass?: Type<StorageOptions>;
+    useExisting?: InjectionToken;
+    useFactory?: (...args: any[]) => Promise<StorageOptions> | StorageOptions;
 }

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

@@ -1,11 +1,13 @@
 import { Buffer } from 'buffer';
 import { Readable } from 'stream';
 import { GetObjectSignedUrlOptions, ObjectInfo, PutObjectOptions } from '../interfaces/connection.interfaces.js';
-import { S3StorageOptions } from '../interfaces/storage.interfaces.js';
+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: S3StorageOptions);
+    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

@@ -1,9 +1,6 @@
-import { DynamicModule, Provider } from '@nestjs/common';
+import { DynamicModule } from '@nestjs/common';
 import { StorageModuleAsyncOptions, StorageModuleOptions } from './interfaces/storage.interfaces.js';
 export declare class StorageCoreModule {
     static register(options: StorageModuleOptions): DynamicModule;
-    static forRootAsync(asyncOptions: StorageModuleAsyncOptions): DynamicModule;
-    static createAsyncProviders(asyncOptions: StorageModuleAsyncOptions): Provider[];
-    static createAsyncOptionsProvider(asyncOptions: StorageModuleAsyncOptions): Provider;
-    private static createFactoryWrapper;
+    static registerAsync(asyncOptions: StorageModuleAsyncOptions): DynamicModule;
 }

package/types/storage.constants.d.ts

@@ -1 +1 @@
-export declare const STORAGE_MODULE_TOKEN: unique symbol;
+export declare const STORAGE_OPTIONS: unique symbol;

package/types/storage.utils.d.ts

@@ -1,4 +1,3 @@
-import { AbstractType, StorageModuleOptions } from './interfaces/storage.interfaces.js';
+import { StorageOptions } from './interfaces/storage.interfaces.js';
 import { StorageConnection } from './services/storage-connection.js';
-export declare function getStorageConnectionToken(name?: string | symbol | AbstractType<StorageConnection>): string | symbol | AbstractType<StorageConnection>;
-export declare function createConnection(options: StorageModuleOptions): StorageConnection;
+export declare function createConnection(options: StorageOptions): StorageConnection;

package/cjs/storage.decorators.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectStorage = void 0;
-const common_1 = require("@nestjs/common");
-const storage_utils_js_1 = require("./storage.utils.js");
-const InjectStorage = (connection) => (0, common_1.Inject)((0, storage_utils_js_1.getStorageConnectionToken)(connection));
-exports.InjectStorage = InjectStorage;

package/esm/storage.decorators.js

@@ -1,3 +0,0 @@
-import { Inject } from '@nestjs/common';
-import { getStorageConnectionToken } from './storage.utils.js';
-export const InjectStorage = (connection) => Inject(getStorageConnectionToken(connection));

package/types/storage.decorators.d.ts

@@ -1 +0,0 @@
-export declare const InjectStorage: (connection?: string) => ParameterDecorator;