@xnestjs/storage 1.2.4 → 1.3.1

package/README.md

@@ -1,3 +1,91 @@
 # @xnestjs/storage
 
 NestJS extension library for Storage solutions (S3,GS)
+
+## Install
+
+```sh
+npm install @xnestjs/storage
+# or using yarn
+yarn add @xnestjs/storage
+```
+
+## Usage
+
+### Register sync
+
+An example of nestjs module that import the @xnestjs/storage
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { StorageModule } from '@xnestjs/storage';
+
+@Module({
+    imports: [
+        StorageModule.forRoot({
+            useValue: {
+                provider: 's3',
+                s3: {
+                    endPoint: 'play.min.io',
+                    port: 9000,
+                    useSSL: true,
+                    accessKey: 'accessKey',
+                    secretKey: 'secretKey',
+                },
+            },
+        }),
+    ],
+})
+export class MyModule {
+}
+```
+
+### Register async
+
+An example of nestjs module that import the @xnestjs/mongodb async
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { StorageModule } from '@xnestjs/storage';
+
+@Module({
+    imports: [
+        StorageModule.forRootAsync({
+            inject: [ConfigModule],
+            useFactory: (config: ConfigService) => ({
+                provider: 's3',
+                s3: {
+                    endPoint: config.get('S3_ENDPOINT'),
+                },
+            }),
+        }),
+    ],
+})
+export class MyModule {
+}
+```
+
+## Environment Variables
+
+The library supports configuration through environment variables. Environment variables below is accepted.
+All environment variables starts with prefix (STORAGE_). This can be configured while registering the module.
+
+| Environment Variable | Type | Default | Description                         |
+|----------------------|------|---------|-------------------------------------|
+| STORAGE_PROVIDER     | Enum |         | Storage Provider `s3` for Amazon S3 |
+
+## Amazon S3 Environment Variables
+
+| Environment Variable     | Type    | Default | Description     |
+|--------------------------|---------|---------|-----------------|
+| STORAGE_S3_ENDPOINT      | String  |         | S3 Endpoint URL |
+| STORAGE_S3_SECRET_KEY    | String  |         |                 |
+| STORAGE_S3_SSL           | Boolean |         |                 |
+| STORAGE_S3_PORT          | Number  |         |                 |
+| STORAGE_S3_SESSION_TOKEN | String  |         |                 |
+| STORAGE_S3_PART_SIZE     | Number  |         |                 |
+| STORAGE_S3_PATH_STYLE    | Boolean |         |                 |
+| STORAGE_S3_SECRET_KEY    | String  |         |                 |
+| STORAGE_S3_ACC_ENDPOINT  | String  |         |                 |

package/cjs/{storage.constants.js → constants.js}

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

package/cjs/index.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./interfaces/connection.interfaces.js"), exports);
-tslib_1.__exportStar(require("./interfaces/storage.interfaces.js"), exports);
+tslib_1.__exportStar(require("./constants.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.module.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/storage-core.module.js

@@ -1,71 +1,107 @@
 "use strict";
-var StorageCoreModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageCoreModule = void 0;
 const tslib_1 = require("tslib");
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
+const node_process_1 = tslib_1.__importDefault(require("node:process"));
+const objects_1 = require("@jsopen/objects");
 const common_1 = require("@nestjs/common");
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const constants_js_1 = require("./constants.js");
+const s3_storage_connection_js_1 = require("./providers/s3-storage-connection.js");
 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: 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,
-        };
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
+class StorageCoreModule {
+    /**
+     * Configures and returns a dynamic module
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.STORAGE_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
     }
-    static registerAsync(asyncOptions) {
-        let optionsProvider;
-        if (asyncOptions.useFactory) {
-            optionsProvider = {
-                provide: storage_constants_js_1.STORAGE_OPTIONS,
-                inject: asyncOptions.inject || [],
-                useFactory: asyncOptions.useFactory,
-            };
-        }
-        else if (asyncOptions.useExisting) {
-            optionsProvider = {
-                provide: storage_constants_js_1.STORAGE_OPTIONS,
-                useExisting: asyncOptions.useExisting,
-            };
-        }
-        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');
+    /**
+     * Configures and returns an async dynamic module
+     */
+    static forRootAsync(asyncOptions) {
+        node_assert_1.default.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.STORAGE_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
+                },
+            ],
+        });
+    }
+    static _readConnectionOptions(moduleOptions, prefix = 'STORAGE_') {
+        const options = (0, objects_1.clone)(moduleOptions);
+        const env = node_process_1.default.env;
+        options.provider = options.provider || env[prefix + 'PROVIDER'];
+        if (options.provider === 's3') {
+            options.s3 = options.s3 || {};
+            options.s3.endPoint = options.s3.endPoint ?? env[prefix + 'S3_ENDPOINT'];
+            options.s3.secretKey = options.s3.secretKey ?? env[prefix + 'S3_SECRET_KEY'];
+            options.s3.useSSL = options.s3.useSSL ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'S3_SSL']);
+            options.s3.port = options.s3.port ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'S3_PORT']);
+            options.s3.sessionToken = options.s3.sessionToken ?? env[prefix + 'S3_SESSION_TOKEN'];
+            options.s3.partSize = options.s3.partSize ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'S3_PART_SIZE']);
+            options.s3.pathStyle = options.s3.pathStyle ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'S3_PATH_STYLE']);
+            options.s3.secretKey = options.s3.secretKey ?? env[prefix + 'S3_SECRET_KEY'];
+            options.s3.s3AccelerateEndpoint = options.s3.s3AccelerateEndpoint ?? env[prefix + 'S3_ACC_ENDPOINT'];
         }
-        const storageToken = asyncOptions.token || storage_connection_js_1.StorageConnection;
+        return options;
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.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),
+                provide: token,
+                inject: [constants_js_1.STORAGE_OPTIONS],
+                useFactory: async (storageOptions) => {
+                    if (storageOptions.provider === 's3') {
+                        if (!storageOptions.s3)
+                            throw new Error('You must provide S3 config');
+                        return new s3_storage_connection_js_1.S3StorageConnection(storageOptions.s3);
+                    }
+                    throw new Error(`Unknown Storage provider (${storageOptions.provider})`);
+                },
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: common_1.Logger,
+                useValue: typeof opts.logger === 'string' ? new common_1.Logger(opts.logger) : opts.logger,
             },
         ];
-        if (asyncOptions.providers)
-            providers.push(...asyncOptions.providers);
         return {
-            module: StorageCoreModule_1,
-            imports: asyncOptions.imports || [],
-            exports: [storageToken, ...(asyncOptions.exports || [])],
-            providers,
-            global: asyncOptions.global,
+            module: StorageCoreModule,
+            ...metadata,
+            providers: [
+                ...(metadata.providers ?? []),
+                ...providers,
+                {
+                    provide: constants_js_1.STORAGE_MODULE_ID,
+                    useValue: crypto_1.default.randomUUID(),
+                },
+            ],
+            exports: [constants_js_1.STORAGE_OPTIONS, token, ...(metadata.exports ?? [])],
         };
     }
-};
+}
 exports.StorageCoreModule = StorageCoreModule;
-exports.StorageCoreModule = StorageCoreModule = StorageCoreModule_1 = tslib_1.__decorate([
-    (0, common_1.Global)(),
-    (0, common_1.Module)({})
-], StorageCoreModule);

package/cjs/storage.module.js

@@ -6,17 +6,17 @@ const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const storage_core_module_js_1 = require("./storage-core.module.js");
 let StorageModule = StorageModule_1 = class StorageModule {
-    static register(options) {
+    static forRoot(options) {
         return {
             module: StorageModule_1,
-            imports: [storage_core_module_js_1.StorageCoreModule.register(options)],
+            imports: [storage_core_module_js_1.StorageCoreModule.forRoot(options)],
             global: options.global,
         };
     }
-    static registerAsync(options) {
+    static forRootAsync(options) {
         return {
             module: StorageModule_1,
-            imports: [storage_core_module_js_1.StorageCoreModule.registerAsync(options)],
+            imports: [storage_core_module_js_1.StorageCoreModule.forRootAsync(options)],
             global: options.global,
         };
     }

package/esm/constants.js

@@ -0,0 +1,2 @@
+export const STORAGE_OPTIONS = Symbol('STORAGE_OPTIONS');
+export const STORAGE_MODULE_ID = Symbol('STORAGE_MODULE_ID');

package/esm/index.js

@@ -1,6 +1,5 @@
-export * from './interfaces/connection.interfaces.js';
-export * from './interfaces/storage.interfaces.js';
+export * from './constants.js';
 export * from './services/storage-bucket.js';
 export * from './services/storage-connection.js';
-export * from './storage.constants.js';
 export * from './storage.module.js';
+export * from './types.js';

package/esm/storage-core.module.js

@@ -1,68 +1,102 @@
-var StorageCoreModule_1;
-import { __decorate } from "tslib";
-import { Global, Module } from '@nestjs/common';
+import assert from 'node:assert';
+import process from 'node:process';
+import { clone } from '@jsopen/objects';
+import { Logger } from '@nestjs/common';
+import crypto from 'crypto';
+import { toBoolean, toInt } from 'putil-varhelpers';
+import { STORAGE_MODULE_ID, STORAGE_OPTIONS } from './constants.js';
+import { S3StorageConnection } from './providers/s3-storage-connection.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: options.token || StorageConnection,
-            useValue: createConnection(options),
-        };
-        return {
-            module: StorageCoreModule_1,
-            providers: [connectionProvider],
-            exports: [connectionProvider],
-            global: options.global,
-        };
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
+export class StorageCoreModule {
+    /**
+     * Configures and returns a dynamic module
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: STORAGE_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
     }
-    static registerAsync(asyncOptions) {
-        let optionsProvider;
-        if (asyncOptions.useFactory) {
-            optionsProvider = {
-                provide: STORAGE_OPTIONS,
-                inject: asyncOptions.inject || [],
-                useFactory: asyncOptions.useFactory,
-            };
-        }
-        else if (asyncOptions.useExisting) {
-            optionsProvider = {
-                provide: STORAGE_OPTIONS,
-                useExisting: asyncOptions.useExisting,
-            };
-        }
-        else if (asyncOptions.useClass) {
-            optionsProvider = {
-                provide: STORAGE_OPTIONS,
-                useClass: asyncOptions.useClass,
-            };
-        }
-        else {
-            throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    /**
+     * Configures and returns an async dynamic module
+     */
+    static forRootAsync(asyncOptions) {
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: STORAGE_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
+                },
+            ],
+        });
+    }
+    static _readConnectionOptions(moduleOptions, prefix = 'STORAGE_') {
+        const options = clone(moduleOptions);
+        const env = process.env;
+        options.provider = options.provider || env[prefix + 'PROVIDER'];
+        if (options.provider === 's3') {
+            options.s3 = options.s3 || {};
+            options.s3.endPoint = options.s3.endPoint ?? env[prefix + 'S3_ENDPOINT'];
+            options.s3.secretKey = options.s3.secretKey ?? env[prefix + 'S3_SECRET_KEY'];
+            options.s3.useSSL = options.s3.useSSL ?? toBoolean(env[prefix + 'S3_SSL']);
+            options.s3.port = options.s3.port ?? toInt(env[prefix + 'S3_PORT']);
+            options.s3.sessionToken = options.s3.sessionToken ?? env[prefix + 'S3_SESSION_TOKEN'];
+            options.s3.partSize = options.s3.partSize ?? toInt(env[prefix + 'S3_PART_SIZE']);
+            options.s3.pathStyle = options.s3.pathStyle ?? toBoolean(env[prefix + 'S3_PATH_STYLE']);
+            options.s3.secretKey = options.s3.secretKey ?? env[prefix + 'S3_SECRET_KEY'];
+            options.s3.s3AccelerateEndpoint = options.s3.s3AccelerateEndpoint ?? env[prefix + 'S3_ACC_ENDPOINT'];
         }
-        const storageToken = asyncOptions.token || StorageConnection;
+        return options;
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? StorageConnection;
         const providers = [
-            optionsProvider,
             {
-                provide: storageToken,
+                provide: token,
                 inject: [STORAGE_OPTIONS],
-                useFactory: (options) => createConnection(options),
+                useFactory: async (storageOptions) => {
+                    if (storageOptions.provider === 's3') {
+                        if (!storageOptions.s3)
+                            throw new Error('You must provide S3 config');
+                        return new S3StorageConnection(storageOptions.s3);
+                    }
+                    throw new Error(`Unknown Storage provider (${storageOptions.provider})`);
+                },
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: Logger,
+                useValue: typeof opts.logger === 'string' ? new Logger(opts.logger) : opts.logger,
             },
         ];
-        if (asyncOptions.providers)
-            providers.push(...asyncOptions.providers);
         return {
-            module: StorageCoreModule_1,
-            imports: asyncOptions.imports || [],
-            exports: [storageToken, ...(asyncOptions.exports || [])],
-            providers,
-            global: asyncOptions.global,
+            module: StorageCoreModule,
+            ...metadata,
+            providers: [
+                ...(metadata.providers ?? []),
+                ...providers,
+                {
+                    provide: STORAGE_MODULE_ID,
+                    useValue: crypto.randomUUID(),
+                },
+            ],
+            exports: [STORAGE_OPTIONS, token, ...(metadata.exports ?? [])],
         };
     }
-};
-StorageCoreModule = StorageCoreModule_1 = __decorate([
-    Global(),
-    Module({})
-], StorageCoreModule);
-export { StorageCoreModule };
+}

package/esm/storage.module.js

@@ -3,17 +3,17 @@ import { __decorate } from "tslib";
 import { Module } from '@nestjs/common';
 import { StorageCoreModule } from './storage-core.module.js';
 let StorageModule = StorageModule_1 = class StorageModule {
-    static register(options) {
+    static forRoot(options) {
         return {
             module: StorageModule_1,
-            imports: [StorageCoreModule.register(options)],
+            imports: [StorageCoreModule.forRoot(options)],
             global: options.global,
         };
     }
-    static registerAsync(options) {
+    static forRootAsync(options) {
         return {
             module: StorageModule_1,
-            imports: [StorageCoreModule.registerAsync(options)],
+            imports: [StorageCoreModule.forRootAsync(options)],
             global: options.global,
         };
     }

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@xnestjs/storage",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "description": "NestJS extension library for Storage solutions (S3,GS)",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
+    "@jsopen/objects": "^1.5.2",
+    "ansi-colors": "^4.1.3",
+    "putil-varhelpers": "^1.6.5",
     "tslib": "^2.8.1"
   },
   "peerDependencies": {

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const STORAGE_OPTIONS: unique symbol;
+export declare const STORAGE_MODULE_ID: unique symbol;

package/types/index.d.cts

@@ -1,6 +1,5 @@
-export * from './interfaces/connection.interfaces.js';
-export * from './interfaces/storage.interfaces.js';
+export * from './constants.js';
 export * from './services/storage-bucket.js';
 export * from './services/storage-connection.js';
-export * from './storage.constants.js';
 export * from './storage.module.js';
+export * from './types.js';

package/types/index.d.ts

@@ -1,6 +1,5 @@
-export * from './interfaces/connection.interfaces.js';
-export * from './interfaces/storage.interfaces.js';
+export * from './constants.js';
 export * from './services/storage-bucket.js';
 export * from './services/storage-connection.js';
-export * from './storage.constants.js';
 export * from './storage.module.js';
+export * from './types.js';

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

@@ -1,8 +1,7 @@
 import { Buffer } from 'buffer';
 import { Readable } from 'stream';
-import { GetObjectSignedUrlOptions, ObjectInfo, PutObjectOptions } from '../interfaces/connection.interfaces.js';
-import { S3Config } from '../interfaces/storage.interfaces.js';
 import { StorageConnection } from '../services/storage-connection.js';
+import type { GetObjectSignedUrlOptions, ObjectInfo, PutObjectOptions, S3Config } from '../types.js';
 export declare class S3StorageConnection extends StorageConnection {
     readonly provider = "s3";
     readonly config: S3Config;

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

@@ -1,6 +1,6 @@
 import type { Buffer } from 'buffer';
 import type { Readable } from 'stream';
-import type { GetObjectSignedUrlOptions, ObjectInfo, PutObjectOptions } from '../interfaces/connection.interfaces.js';
+import type { GetObjectSignedUrlOptions, ObjectInfo, PutObjectOptions } from '../types.js';
 import type { StorageConnection } from './storage-connection';
 export declare class StorageBucket {
     private _connection;

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

@@ -1,7 +1,7 @@
 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 type { StorageProvider } from '../types';
+import type { GetObjectSignedUrlOptions, ObjectInfo, PutObjectOptions } from '../types.js';
 import { StorageBucket } from './storage-bucket.js';
 export declare abstract class StorageConnection {
     abstract readonly provider: StorageProvider;

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

@@ -1,6 +1,14 @@
 import { DynamicModule } from '@nestjs/common';
-import { StorageModuleAsyncOptions, StorageModuleOptions } from './interfaces/storage.interfaces.js';
+import type { StorageModuleAsyncOptions, StorageModuleOptions } from './types.js';
 export declare class StorageCoreModule {
-    static register(options: StorageModuleOptions): DynamicModule;
-    static registerAsync(asyncOptions: StorageModuleAsyncOptions): DynamicModule;
+    /**
+     * Configures and returns a dynamic module
+     */
+    static forRoot(moduleOptions: StorageModuleOptions): DynamicModule;
+    /**
+     * Configures and returns an async dynamic module
+     */
+    static forRootAsync(asyncOptions: StorageModuleAsyncOptions): DynamicModule;
+    private static _readConnectionOptions;
+    private static _createDynamicModule;
 }

package/types/storage.module.d.ts

@@ -1,6 +1,6 @@
 import { DynamicModule } from '@nestjs/common';
-import { StorageModuleAsyncOptions, StorageModuleOptions } from './interfaces/storage.interfaces.js';
+import type { StorageModuleAsyncOptions, StorageModuleOptions } from './types.js';
 export declare class StorageModule {
-    static register(options: StorageModuleOptions): DynamicModule;
-    static registerAsync(options: StorageModuleAsyncOptions): DynamicModule;
+    static forRoot(options: StorageModuleOptions): DynamicModule;
+    static forRootAsync(options: StorageModuleAsyncOptions): DynamicModule;
 }

package/types/types.d.ts

@@ -0,0 +1,52 @@
+import type { InjectionToken, Logger } from '@nestjs/common';
+import type { ModuleMetadata } from '@nestjs/common/interfaces';
+import type * as minio from 'minio';
+export type S3Config = minio.ClientOptions & {
+    rejectUnauthorized?: boolean;
+};
+export type StorageProvider = 's3';
+/**
+ * Amazon S3
+ */
+export interface S3StorageOptions {
+    provider: 's3';
+    s3: S3Config;
+}
+export type StorageOptions = S3StorageOptions;
+export interface StorageModuleOptions extends BaseModuleOptions {
+    useValue: StorageOptions;
+}
+export interface StorageModuleAsyncOptions extends BaseModuleOptions, Pick<ModuleMetadata, 'imports'> {
+    useFactory?: (...args: any[]) => Promise<StorageOptions> | StorageOptions;
+    inject?: any[];
+}
+interface BaseModuleOptions {
+    token?: InjectionToken;
+    envPrefix?: string;
+    logger?: Logger | string;
+    global?: boolean;
+}
+export type FileMetadata = Record<string, any>;
+export interface ObjectInfo {
+    originalName?: string;
+    contentType?: string;
+    contentLanguage?: string;
+    contentEncoding?: string;
+    size: number;
+    etag: string;
+    lastModified: Date;
+    metadata: Record<string, any>;
+}
+export interface PutObjectOptions {
+    originalName?: string;
+    contentType?: string;
+    contentLanguage?: string;
+    contentEncoding?: string;
+    metadata?: FileMetadata;
+}
+export interface SignedUrlOptions {
+    expires?: number;
+}
+export interface GetObjectSignedUrlOptions extends SignedUrlOptions {
+}
+export {};

package/cjs/interfaces/storage.interfaces.js

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

package/cjs/storage.utils.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConnection = createConnection;
-const s3_storage_connection_js_1 = require("./providers/s3-storage-connection.js");
-function createConnection(options) {
-    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/interfaces/storage.interfaces.js

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

package/esm/storage.constants.js

@@ -1 +0,0 @@
-export const STORAGE_OPTIONS = Symbol('STORAGE_OPTIONS');

package/esm/storage.utils.js

@@ -1,9 +0,0 @@
-import { S3StorageConnection } from './providers/s3-storage-connection.js';
-export function createConnection(options) {
-    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/types/interfaces/connection.interfaces.d.ts

@@ -1,23 +0,0 @@
-export type FileMetadata = Record<string, any>;
-export interface ObjectInfo {
-    originalName?: string;
-    contentType?: string;
-    contentLanguage?: string;
-    contentEncoding?: string;
-    size: number;
-    etag: string;
-    lastModified: Date;
-    metadata: Record<string, any>;
-}
-export interface PutObjectOptions {
-    originalName?: string;
-    contentType?: string;
-    contentLanguage?: string;
-    contentEncoding?: string;
-    metadata?: FileMetadata;
-}
-export interface SignedUrlOptions {
-    expires?: number;
-}
-export interface GetObjectSignedUrlOptions extends SignedUrlOptions {
-}

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

@@ -1,28 +0,0 @@
-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 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 & {
-    token?: InjectionToken;
-    global?: boolean;
-};
-export interface StorageModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'exports' | 'providers'> {
-    token?: InjectionToken;
-    inject?: any[];
-    global?: boolean;
-    useClass?: Type<StorageOptions>;
-    useExisting?: InjectionToken;
-    useFactory?: (...args: any[]) => Promise<StorageOptions> | StorageOptions;
-}

package/types/storage.constants.d.ts

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

package/types/storage.utils.d.ts

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