@xnestjs/storage 1.0.1 → 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+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/cjs/index.js

@@ -0,0 +1,9 @@
+"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("./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);

package/cjs/interfaces/connection.interfaces.js

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

package/cjs/interfaces/storage.interfaces.js

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

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3StorageConnection = void 0;
+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(config) {
+        super();
+        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) : {};
+        if (typeof source === 'string')
+            await this._client.fPutObject(bucketName, objectName, source, meta);
+        else
+            await this._client.putObject(bucketName, objectName, source, undefined, meta);
+    }
+    async getObjectInfo(bucketName, objectName) {
+        const o = await this._client.statObject(bucketName, objectName);
+        const inf = {
+            size: o.size,
+            etag: o.etag,
+            lastModified: o.lastModified,
+            metadata: o.metaData,
+        };
+        if (inf.metadata) {
+            const meta = inf.metadata;
+            removeKey(meta, 'content-length');
+            removeKey(meta, 'last-modified');
+            if (meta['Content-Type']) {
+                inf.contentLanguage = meta['Content-Type'];
+                removeKey(meta, 'content-type');
+            }
+            if (meta['Content-Language']) {
+                inf.contentLanguage = meta['Content-Language'];
+                removeKey(meta, 'content-language');
+            }
+            if (meta['Content-Encoding']) {
+                inf.contentEncoding = meta['Content-Encoding'];
+                removeKey(meta, 'content-encoding');
+            }
+            if (meta['Content-Name']) {
+                inf.originalName = meta['Content-Name'];
+                removeKey(meta, 'content-name');
+            }
+        }
+        return inf;
+    }
+    async removeObject(bucketName, objectName) {
+        await this._client.removeObject(bucketName, objectName);
+    }
+    async getFile(bucketName, objectName, filePath) {
+        await this._client.fGetObject(bucketName, objectName, filePath);
+    }
+    getObject(bucketName, objectName) {
+        return this._client.getObject(bucketName, objectName);
+    }
+    presignedGetObject(bucketName, objectName, options) {
+        const expires = options?.expires || 5 * 60 * 60; // 5 minutes
+        return this._client.presignedGetObject(bucketName, objectName, expires);
+    }
+}
+exports.S3StorageConnection = S3StorageConnection;
+function updateMetadata(meta, options) {
+    if (!options)
+        return meta;
+    const newMeta = { ...meta };
+    if (options.contentType) {
+        removeKey(newMeta, 'content-type');
+        newMeta['Content-Type'] = options.contentType;
+    }
+    if (options.contentLanguage) {
+        removeKey(newMeta, 'content-language');
+        newMeta['Content-Language'] = options.contentLanguage;
+    }
+    if (options.contentEncoding) {
+        removeKey(newMeta, 'content-encoding');
+        newMeta['Content-Encoding'] = options.contentLanguage;
+    }
+    if (options.originalName) {
+        removeKey(newMeta, 'content-name');
+        newMeta['Content-Name'] = options.originalName;
+    }
+    return newMeta;
+}
+function removeKey(obj, key) {
+    key = key.toLowerCase();
+    const k = Object.keys(obj).find(x => x.toLowerCase() === key);
+    if (k)
+        delete obj[k];
+}

package/cjs/services/storage-bucket.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageBucket = void 0;
+class StorageBucket {
+    constructor(_connection, _bucketName) {
+        this._connection = _connection;
+        this._bucketName = _bucketName;
+    }
+    putObject(objectName, buffer, options) {
+        return this._connection.putObject(this._bucketName, objectName, buffer, options);
+    }
+    getObjectInfo(objectName) {
+        return this._connection.getObjectInfo(this._bucketName, objectName);
+    }
+    removeObject(objectName) {
+        return this._connection.removeObject(this._bucketName, objectName);
+    }
+    getFile(objectName, filePath) {
+        return this._connection.getFile(this._bucketName, objectName, filePath);
+    }
+    getObject(objectName) {
+        return this._connection.getObject(this._bucketName, objectName);
+    }
+    presignedGetObject(objectName, options) {
+        return this._connection.presignedGetObject(this._bucketName, objectName, options);
+    }
+}
+exports.StorageBucket = StorageBucket;

package/cjs/services/storage-connection.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageConnection = void 0;
+const storage_bucket_js_1 = require("./storage-bucket.js");
+class StorageConnection {
+    getBucket(bucketName) {
+        return new storage_bucket_js_1.StorageBucket(this, bucketName);
+    }
+}
+exports.StorageConnection = StorageConnection;

package/cjs/storage-core.module.js

@@ -0,0 +1,71 @@
+"use strict";
+var StorageCoreModule_1;
+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: 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 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');
+        }
+        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,
+        };
+    }
+};
+exports.StorageCoreModule = StorageCoreModule;
+exports.StorageCoreModule = StorageCoreModule = StorageCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], StorageCoreModule);

package/cjs/storage.constants.js

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

package/cjs/storage.module.js

@@ -0,0 +1,27 @@
+"use strict";
+var StorageModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageModule = void 0;
+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) {
+        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.registerAsync(options)],
+            global: options.global,
+        };
+    }
+};
+exports.StorageModule = StorageModule;
+exports.StorageModule = StorageModule = StorageModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], StorageModule);

package/cjs/storage.utils.js

@@ -0,0 +1,12 @@
+"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/index.js

@@ -0,0 +1,6 @@
+export * from './interfaces/connection.interfaces.js';
+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.module.js';

package/esm/interfaces/connection.interfaces.js

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

package/esm/interfaces/storage.interfaces.js

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

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

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

@@ -0,0 +1,90 @@
+import * as Minio from 'minio';
+import { StorageConnection } from '../services/storage-connection.js';
+export class S3StorageConnection extends StorageConnection {
+    constructor(config) {
+        super();
+        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) : {};
+        if (typeof source === 'string')
+            await this._client.fPutObject(bucketName, objectName, source, meta);
+        else
+            await this._client.putObject(bucketName, objectName, source, undefined, meta);
+    }
+    async getObjectInfo(bucketName, objectName) {
+        const o = await this._client.statObject(bucketName, objectName);
+        const inf = {
+            size: o.size,
+            etag: o.etag,
+            lastModified: o.lastModified,
+            metadata: o.metaData,
+        };
+        if (inf.metadata) {
+            const meta = inf.metadata;
+            removeKey(meta, 'content-length');
+            removeKey(meta, 'last-modified');
+            if (meta['Content-Type']) {
+                inf.contentLanguage = meta['Content-Type'];
+                removeKey(meta, 'content-type');
+            }
+            if (meta['Content-Language']) {
+                inf.contentLanguage = meta['Content-Language'];
+                removeKey(meta, 'content-language');
+            }
+            if (meta['Content-Encoding']) {
+                inf.contentEncoding = meta['Content-Encoding'];
+                removeKey(meta, 'content-encoding');
+            }
+            if (meta['Content-Name']) {
+                inf.originalName = meta['Content-Name'];
+                removeKey(meta, 'content-name');
+            }
+        }
+        return inf;
+    }
+    async removeObject(bucketName, objectName) {
+        await this._client.removeObject(bucketName, objectName);
+    }
+    async getFile(bucketName, objectName, filePath) {
+        await this._client.fGetObject(bucketName, objectName, filePath);
+    }
+    getObject(bucketName, objectName) {
+        return this._client.getObject(bucketName, objectName);
+    }
+    presignedGetObject(bucketName, objectName, options) {
+        const expires = options?.expires || 5 * 60 * 60; // 5 minutes
+        return this._client.presignedGetObject(bucketName, objectName, expires);
+    }
+}
+function updateMetadata(meta, options) {
+    if (!options)
+        return meta;
+    const newMeta = { ...meta };
+    if (options.contentType) {
+        removeKey(newMeta, 'content-type');
+        newMeta['Content-Type'] = options.contentType;
+    }
+    if (options.contentLanguage) {
+        removeKey(newMeta, 'content-language');
+        newMeta['Content-Language'] = options.contentLanguage;
+    }
+    if (options.contentEncoding) {
+        removeKey(newMeta, 'content-encoding');
+        newMeta['Content-Encoding'] = options.contentLanguage;
+    }
+    if (options.originalName) {
+        removeKey(newMeta, 'content-name');
+        newMeta['Content-Name'] = options.originalName;
+    }
+    return newMeta;
+}
+function removeKey(obj, key) {
+    key = key.toLowerCase();
+    const k = Object.keys(obj).find(x => x.toLowerCase() === key);
+    if (k)
+        delete obj[k];
+}

package/esm/services/storage-bucket.js

@@ -0,0 +1,24 @@
+export class StorageBucket {
+    constructor(_connection, _bucketName) {
+        this._connection = _connection;
+        this._bucketName = _bucketName;
+    }
+    putObject(objectName, buffer, options) {
+        return this._connection.putObject(this._bucketName, objectName, buffer, options);
+    }
+    getObjectInfo(objectName) {
+        return this._connection.getObjectInfo(this._bucketName, objectName);
+    }
+    removeObject(objectName) {
+        return this._connection.removeObject(this._bucketName, objectName);
+    }
+    getFile(objectName, filePath) {
+        return this._connection.getFile(this._bucketName, objectName, filePath);
+    }
+    getObject(objectName) {
+        return this._connection.getObject(this._bucketName, objectName);
+    }
+    presignedGetObject(objectName, options) {
+        return this._connection.presignedGetObject(this._bucketName, objectName, options);
+    }
+}

package/esm/services/storage-connection.js

@@ -0,0 +1,6 @@
+import { StorageBucket } from './storage-bucket.js';
+export class StorageConnection {
+    getBucket(bucketName) {
+        return new StorageBucket(this, bucketName);
+    }
+}

package/esm/storage-core.module.js

@@ -0,0 +1,68 @@
+var StorageCoreModule_1;
+import { __decorate } from "tslib";
+import { Global, Module } from '@nestjs/common';
+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,
+        };
+    }
+    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');
+        }
+        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,
+        };
+    }
+};
+StorageCoreModule = StorageCoreModule_1 = __decorate([
+    Global(),
+    Module({})
+], StorageCoreModule);
+export { StorageCoreModule };

package/esm/storage.constants.js

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

package/esm/storage.module.js

@@ -0,0 +1,24 @@
+var StorageModule_1;
+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) {
+        return {
+            module: StorageModule_1,
+            imports: [StorageCoreModule.register(options)],
+            global: options.global,
+        };
+    }
+    static registerAsync(options) {
+        return {
+            module: StorageModule_1,
+            imports: [StorageCoreModule.registerAsync(options)],
+            global: options.global,
+        };
+    }
+};
+StorageModule = StorageModule_1 = __decorate([
+    Module({})
+], StorageModule);
+export { StorageModule };

package/esm/storage.utils.js

@@ -0,0 +1,9 @@
+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/package.json

@@ -1,36 +1,15 @@
 {
   "name": "@xnestjs/storage",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "NestJS extension library for Storage solutions (S3,GS)",
   "author": "Panates",
   "license": "MIT",
-  "scripts": {
-    "compile": "tsc --noEmit",
-    "prebuild": "npm run lint && npm run clean",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -b tsconfig-build-cjs.json && cp ../../support/package.cjs.json ./build/cjs/package.json",
-    "build:esm": "tsc -b tsconfig-build-esm.json && cp ../../support/package.esm.json ./build/esm/package.json",
-    "postbuild": "cp README.md ../../LICENSE ./build && node ../../support/postbuild.cjs",
-    "lint": "eslint . --max-warnings=0",
-    "lint:fix": "eslint . --max-warnings=0 --fix",
-    "format": "prettier . --write --log-level=warn",
-    "check": "madge --circular src/**",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
-    "clean": "npm run clean:src && npm run clean:build && npm run clean:cover",
-    "clean:src": "ts-cleanup -s src --all && ts-cleanup -s test --all",
-    "clean:build": "rimraf build",
-    "clean:cover": "rimraf coverage"
-  },
   "peerDependencies": {
     "@nestjs/common": "^10.4.15"
   },
   "optionalDependencies": {
     "minio": "^8.0.3"
   },
-  "devDependencies": {
-    "@nestjs/testing": "^10.4.15"
-  },
   "type": "module",
   "exports": {
     ".": {
@@ -69,4 +48,4 @@
     "storage",
     "s3"
   ]
-}
+}

package/types/index.d.cts

@@ -0,0 +1,6 @@
+export * from './interfaces/connection.interfaces.js';
+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.module.js';

package/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './interfaces/connection.interfaces.js';
+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.module.js';

package/types/interfaces/connection.interfaces.d.ts

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,28 @@
+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/providers/s3-storage-connection.d.ts

@@ -0,0 +1,17 @@
+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';
+export declare class S3StorageConnection extends StorageConnection {
+    readonly provider = "s3";
+    readonly config: S3Config;
+    private _client;
+    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>;
+    getFile(bucketName: string, objectName: string, filePath: string): Promise<void>;
+    getObject(bucketName: string, objectName: string): Promise<Readable>;
+    presignedGetObject(bucketName: string, objectName: string, options?: GetObjectSignedUrlOptions): Promise<string>;
+}

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

@@ -0,0 +1,15 @@
+import type { Buffer } from 'buffer';
+import type { Readable } from 'stream';
+import type { GetObjectSignedUrlOptions, ObjectInfo, PutObjectOptions } from '../interfaces/connection.interfaces.js';
+import type { StorageConnection } from './storage-connection';
+export declare class StorageBucket {
+    private _connection;
+    private _bucketName;
+    constructor(_connection: StorageConnection, _bucketName: string);
+    putObject(objectName: string, buffer: Buffer | Readable | string, options?: PutObjectOptions): Promise<void>;
+    getObjectInfo(objectName: string): Promise<ObjectInfo>;
+    removeObject(objectName: string): Promise<void>;
+    getFile(objectName: string, filePath: string): Promise<void>;
+    getObject(objectName: string): Promise<Readable>;
+    presignedGetObject(objectName: string, options?: GetObjectSignedUrlOptions): Promise<string>;
+}

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

@@ -0,0 +1,19 @@
+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>;
+    abstract putObject(bucketName: string, objectName: string, filePath: string, options?: PutObjectOptions): Promise<void>;
+    abstract putObject(bucketName: string, objectName: string, source: Buffer | Readable | string, options?: PutObjectOptions): Promise<void>;
+    abstract getObjectInfo(bucketName: string, objectName: string): Promise<ObjectInfo>;
+    abstract removeObject(bucketName: string, objectName: string): Promise<void>;
+    abstract getFile(bucketName: string, objectName: string, filePath: string): Promise<void>;
+    abstract getObject(bucketName: string, objectName: string): Promise<Readable>;
+    abstract presignedGetObject(bucketName: string, objectName: string, options?: GetObjectSignedUrlOptions): Promise<string>;
+}

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

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

package/types/storage.constants.d.ts

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

package/types/storage.module.d.ts

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

package/types/storage.utils.d.ts

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