@flusys/nestjs-storage 6.4.1 → 7.0.0-beta.1

package/cjs/config/event-actions.js

@@ -0,0 +1,34 @@
+/**
+ * Domain event actions published by the storage module, alongside the CRUD
+ * lifecycle actions every ApiService emits.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get STORAGE_EVENT_ACTIONS () {
+        return STORAGE_EVENT_ACTIONS;
+    },
+    get STORAGE_EVENT_ENTITIES () {
+        return STORAGE_EVENT_ENTITIES;
+    },
+    get STORAGE_EVENT_MODULE () {
+        return STORAGE_EVENT_MODULE;
+    }
+});
+const STORAGE_EVENT_ACTIONS = {
+    UPLOADED: 'uploaded',
+    REMOVED: 'removed'
+};
+const STORAGE_EVENT_ENTITIES = {
+    FILE: 'file_manager',
+    FOLDER: 'folder',
+    STORAGE_CONFIG: 'storageConfig'
+};
+const STORAGE_EVENT_MODULE = 'storage';

package/cjs/config/index.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./storage.constants"), exports);
+_export_star(require("./event-actions"), exports);
 _export_star(require("./message-keys"), exports);
+_export_star(require("./storage.constants"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/cjs/config/message-keys.js

@@ -16,6 +16,9 @@ _export(exports, {
     get FOLDER_MESSAGES () {
         return FOLDER_MESSAGES;
     },
+    get STORAGE_CONFIG_MESSAGES () {
+        return STORAGE_CONFIG_MESSAGES;
+    },
     get UPLOAD_MESSAGES () {
         return UPLOAD_MESSAGES;
     }
@@ -25,6 +28,9 @@ const FILE_MESSAGES = {
     DELETE_SUCCESS: 'file.delete.success',
     NOT_FOUND: 'file.not.found'
 };
+const STORAGE_CONFIG_MESSAGES = {
+    DEFAULT_DELETE_FORBIDDEN: 'storage.config.default.delete.forbidden'
+};
 const FOLDER_MESSAGES = {
     NOT_FOUND: 'folder.not.found'
 };

package/cjs/modules/storage.module.js

@@ -121,6 +121,7 @@ let StorageModule = class StorageModule {
                 useValue: options
             });
         }
+        providers.push((0, _modules.createModuleEventsProvider)('storage', _storageconstants.STORAGE_MODULE_OPTIONS));
         return providers;
     }
     static createAsyncProviders(options) {

package/cjs/services/storage-provider-config.service.js

@@ -12,6 +12,8 @@ const _classes = require("@flusys/nestjs-shared/classes");
 const _modules = require("@flusys/nestjs-shared/modules");
 const _utils = require("@flusys/nestjs-shared/utils");
 const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
+const _config = require("../config");
 const _entities = require("../entities");
 const _storageconfigservice = require("./storage-config.service");
 const _storagedatasourceprovider = require("./storage-datasource.provider");
@@ -46,6 +48,29 @@ let StorageProviderConfigService = class StorageProviderConfigService extends _c
     resolveEntity() {
         return this.storageConfig.isCompanyFeatureEnabled() ? _entities.StorageConfigWithCompany : _entities.StorageConfig;
     }
+    async beforeDeleteOperation(dto, _user, _queryRunner) {
+        const ids = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        await this.ensureDataSourceRepository();
+        const defaultConfigs = await this.repository.find({
+            where: {
+                id: (0, _typeorm.In)(ids),
+                isDefault: true,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (defaultConfigs.length > 0) {
+            const names = defaultConfigs.map((c)=>c.name).join(', ');
+            throw new _common.ForbiddenException({
+                message: `Cannot delete the default storage config(s): ${names}. Set another config as default first.`,
+                messageKey: _config.STORAGE_CONFIG_MESSAGES.DEFAULT_DELETE_FORBIDDEN,
+                messageVariables: {
+                    names
+                }
+            });
+        }
+    }
     // ─── Override Methods ───────────────────────────────────────────────────────
     async convertSingleDtoToEntity(dto, user) {
         const entity = await super.convertSingleDtoToEntity(dto, user);

package/cjs/services/storage-provider-config.service.spec.js

@@ -240,4 +240,22 @@ describe('StorageProviderConfigService', ()=>{
             expect(result).toEqual([]);
         });
     });
+    describe('beforeDeleteOperation', ()=>{
+        it('rejects deleting the default storage config', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildStorageConfig({
+                    isDefault: true
+                })
+            ]);
+            await expect(service.beforeDeleteOperation({
+                id: 'config-uuid-1'
+            }, null, {})).rejects.toThrow('Cannot delete the default storage config');
+        });
+        it('allows deleting a non-default storage config', async ()=>{
+            mockRepo.find.mockResolvedValue([]);
+            await expect(service.beforeDeleteOperation({
+                id: 'config-uuid-1'
+            }, null, {})).resolves.toBeUndefined();
+        });
+    });
 });

package/cjs/services/upload.service.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "UploadService", {
     }
 });
 const _nestjsshared = require("@flusys/nestjs-shared");
+const _classes = require("@flusys/nestjs-shared/classes");
 const _interfaces = require("@flusys/nestjs-shared/interfaces");
 const _utils = require("@flusys/nestjs-shared/utils");
 const _common = require("@nestjs/common");
@@ -172,6 +173,14 @@ let UploadService = class UploadService {
         this.validateFile(file);
         const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
         const result = await provider.uploadFile(file, options);
+        await this.publishFileEvent(_config.STORAGE_EVENT_ACTIONS.UPLOADED, [
+            result.key
+        ], user, {
+            location,
+            storageConfigId: configId,
+            totalSize: result.size,
+            count: 1
+        });
         return {
             ...result,
             location,
@@ -184,6 +193,12 @@ let UploadService = class UploadService {
         }
         const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
         const results = await provider.uploadMultipleFiles(files, options);
+        await this.publishFileEvent(_config.STORAGE_EVENT_ACTIONS.UPLOADED, results.map((result)=>result.key), user, {
+            location,
+            storageConfigId: configId,
+            totalSize: results.reduce((sum, result)=>sum + (result.size ?? 0), 0),
+            count: results.length
+        });
         return results.map((result)=>({
                 ...result,
                 location,
@@ -197,6 +212,12 @@ let UploadService = class UploadService {
         });
         const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
         await provider.deleteFile(key);
+        await this.publishFileEvent(_config.STORAGE_EVENT_ACTIONS.REMOVED, [
+            key
+        ], user, {
+            storageConfigId,
+            count: 1
+        });
         return true;
     }
     async deleteMultipleFile(keys, storageConfigId, user, locationHint) {
@@ -206,8 +227,22 @@ let UploadService = class UploadService {
         });
         const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
         await provider.deleteMultipleFiles(keys);
+        await this.publishFileEvent(_config.STORAGE_EVENT_ACTIONS.REMOVED, keys, user, {
+            storageConfigId,
+            count: keys.length
+        });
         return true;
     }
+    async publishFileEvent(action, keys, user, metadata) {
+        await (0, _classes.publishDomainEvent)({
+            module: _config.STORAGE_EVENT_MODULE,
+            entity: _config.STORAGE_EVENT_ENTITIES.FILE,
+            action,
+            ids: keys,
+            metadata,
+            user: user ?? null
+        });
+    }
     bytesToKb(bytes) {
         return Number((bytes * 0.001).toFixed(2));
     }

package/cjs/services/upload.service.spec.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 const _testing = require("@nestjs/testing");
+const _classes = require("@flusys/nestjs-shared/classes");
 const _uploadservice = require("./upload.service");
 const _storagefactoryservice = require("../providers/storage-factory.service");
 const _storageconfigservice = require("./storage-config.service");
@@ -369,4 +370,57 @@ describe('UploadService', ()=>{
             expect(mockProvider.generatePresignedUrl).toHaveBeenCalledWith('uploads/photo.jpg', 3600);
         });
     });
+    describe('domain events', ()=>{
+        let publish;
+        beforeEach(()=>{
+            publish = jest.fn().mockResolvedValue(undefined);
+            _classes.EventBusRegistry.reset();
+            _classes.EventBusRegistry.setBus({
+                publish,
+                subscribe: jest.fn(),
+                close: jest.fn()
+            });
+            _classes.EventBusRegistry.configureModule('storage', {
+                enabled: true
+            });
+            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
+                id: 'cfg-default',
+                storage: 'local',
+                config: {}
+            });
+        });
+        afterEach(()=>{
+            _classes.EventBusRegistry.reset();
+        });
+        it('publishes storage.file_manager.uploaded after a single upload', async ()=>{
+            await service.uploadSingleFile(buildMulterFile(), {}, (0, _loggedusermock.buildMockUser)());
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'storage.file_manager.uploaded',
+                payload: expect.objectContaining({
+                    metadata: expect.objectContaining({
+                        count: 1,
+                        storageConfigId: 'cfg-default'
+                    })
+                })
+            }));
+        });
+        it('publishes storage.file_manager.removed after a delete', async ()=>{
+            await service.deleteSingleFile('uploads/photo.jpg', 'cfg-1', (0, _loggedusermock.buildMockUser)());
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'storage.file_manager.removed',
+                payload: expect.objectContaining({
+                    ids: [
+                        'uploads/photo.jpg'
+                    ]
+                })
+            }));
+        });
+        it('does not publish when the storage module has events disabled', async ()=>{
+            _classes.EventBusRegistry.configureModule('storage', {
+                enabled: false
+            });
+            await service.uploadSingleFile(buildMulterFile(), {}, (0, _loggedusermock.buildMockUser)());
+            expect(publish).not.toHaveBeenCalled();
+        });
+    });
 });

package/config/event-actions.d.ts

@@ -0,0 +1,10 @@
+export declare const STORAGE_EVENT_ACTIONS: {
+    readonly UPLOADED: "uploaded";
+    readonly REMOVED: "removed";
+};
+export declare const STORAGE_EVENT_ENTITIES: {
+    readonly FILE: "file_manager";
+    readonly FOLDER: "folder";
+    readonly STORAGE_CONFIG: "storageConfig";
+};
+export declare const STORAGE_EVENT_MODULE = "storage";

package/config/index.d.ts

@@ -1,2 +1,3 @@
-export * from './storage.constants';
+export * from './event-actions';
 export * from './message-keys';
+export * from './storage.constants';

package/config/message-keys.d.ts

@@ -3,6 +3,9 @@ export declare const FILE_MESSAGES: {
     readonly DELETE_SUCCESS: "file.delete.success";
     readonly NOT_FOUND: "file.not.found";
 };
+export declare const STORAGE_CONFIG_MESSAGES: {
+    readonly DEFAULT_DELETE_FORBIDDEN: "storage.config.default.delete.forbidden";
+};
 export declare const FOLDER_MESSAGES: {
     readonly NOT_FOUND: "folder.not.found";
 };

package/fesm/config/event-actions.js

@@ -0,0 +1,13 @@
+/**
+ * Domain event actions published by the storage module, alongside the CRUD
+ * lifecycle actions every ApiService emits.
+ */ export const STORAGE_EVENT_ACTIONS = {
+    UPLOADED: 'uploaded',
+    REMOVED: 'removed'
+};
+/** Every entity the storage module publishes under, ApiService backed or not */ export const STORAGE_EVENT_ENTITIES = {
+    FILE: 'file_manager',
+    FOLDER: 'folder',
+    STORAGE_CONFIG: 'storageConfig'
+};
+export const STORAGE_EVENT_MODULE = 'storage';

package/fesm/config/index.js

@@ -1,2 +1,3 @@
-export * from './storage.constants';
+export * from './event-actions';
 export * from './message-keys';
+export * from './storage.constants';

package/fesm/config/message-keys.js

@@ -4,6 +4,9 @@ export const FILE_MESSAGES = {
     DELETE_SUCCESS: 'file.delete.success',
     NOT_FOUND: 'file.not.found'
 };
+export const STORAGE_CONFIG_MESSAGES = {
+    DEFAULT_DELETE_FORBIDDEN: 'storage.config.default.delete.forbidden'
+};
 export const FOLDER_MESSAGES = {
     NOT_FOUND: 'folder.not.found'
 };

package/fesm/modules/storage.module.js

@@ -4,7 +4,7 @@ function _ts_decorate(decorators, target, key, desc) {
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-import { CacheModule, UtilsModule } from '@flusys/nestjs-shared/modules';
+import { CacheModule, UtilsModule, createModuleEventsProvider } from '@flusys/nestjs-shared/modules';
 import { Logger, Module, RequestMethod } from '@nestjs/common';
 import { FileServeMiddleware } from '../middlewares';
 import { StorageConfigService } from '../services';
@@ -112,6 +112,7 @@ export class StorageModule {
                 useValue: options
             });
         }
+        providers.push(createModuleEventsProvider('storage', STORAGE_MODULE_OPTIONS));
         return providers;
     }
     static createAsyncProviders(options) {

package/fesm/services/storage-provider-config.service.js

@@ -28,7 +28,9 @@ function _ts_param(paramIndex, decorator) {
 import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { applyCompanyFilter, buildCompanyWhereCondition } from '@flusys/nestjs-shared/utils';
-import { Inject, Injectable, Scope } from '@nestjs/common';
+import { ForbiddenException, Inject, Injectable, Scope } from '@nestjs/common';
+import { In, IsNull } from 'typeorm';
+import { STORAGE_CONFIG_MESSAGES } from '../config';
 import { StorageConfig, StorageConfigWithCompany } from '../entities';
 import { StorageConfigService } from './storage-config.service';
 import { StorageDataSourceProvider } from './storage-datasource.provider';
@@ -36,6 +38,29 @@ export class StorageProviderConfigService extends ApiService {
     resolveEntity() {
         return this.storageConfig.isCompanyFeatureEnabled() ? StorageConfigWithCompany : StorageConfig;
     }
+    async beforeDeleteOperation(dto, _user, _queryRunner) {
+        const ids = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        await this.ensureDataSourceRepository();
+        const defaultConfigs = await this.repository.find({
+            where: {
+                id: In(ids),
+                isDefault: true,
+                deletedAt: IsNull()
+            }
+        });
+        if (defaultConfigs.length > 0) {
+            const names = defaultConfigs.map((c)=>c.name).join(', ');
+            throw new ForbiddenException({
+                message: `Cannot delete the default storage config(s): ${names}. Set another config as default first.`,
+                messageKey: STORAGE_CONFIG_MESSAGES.DEFAULT_DELETE_FORBIDDEN,
+                messageVariables: {
+                    names
+                }
+            });
+        }
+    }
     // ─── Override Methods ───────────────────────────────────────────────────────
     async convertSingleDtoToEntity(dto, user) {
         const entity = await super.convertSingleDtoToEntity(dto, user);

package/fesm/services/storage-provider-config.service.spec.js

@@ -236,4 +236,22 @@ describe('StorageProviderConfigService', ()=>{
             expect(result).toEqual([]);
         });
     });
+    describe('beforeDeleteOperation', ()=>{
+        it('rejects deleting the default storage config', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildStorageConfig({
+                    isDefault: true
+                })
+            ]);
+            await expect(service.beforeDeleteOperation({
+                id: 'config-uuid-1'
+            }, null, {})).rejects.toThrow('Cannot delete the default storage config');
+        });
+        it('allows deleting a non-default storage config', async ()=>{
+            mockRepo.find.mockResolvedValue([]);
+            await expect(service.beforeDeleteOperation({
+                id: 'config-uuid-1'
+            }, null, {})).resolves.toBeUndefined();
+        });
+    });
 });

package/fesm/services/upload.service.js

@@ -26,10 +26,11 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { LogAction } from '@flusys/nestjs-shared';
+import { publishDomainEvent } from '@flusys/nestjs-shared/classes';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { validateCompanyOwnership } from '@flusys/nestjs-shared/utils';
 import { BadRequestException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
-import { UPLOAD_MESSAGES } from '../config';
+import { STORAGE_EVENT_ACTIONS, STORAGE_EVENT_ENTITIES, STORAGE_EVENT_MODULE, UPLOAD_MESSAGES } from '../config';
 import { UploadOptionsDto } from '../dtos/upload.dto';
 import { FileLocationEnum } from '../enums/file-location.enum';
 import { StorageFactoryService } from '../providers/storage-factory.service';
@@ -162,6 +163,14 @@ export class UploadService {
         this.validateFile(file);
         const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
         const result = await provider.uploadFile(file, options);
+        await this.publishFileEvent(STORAGE_EVENT_ACTIONS.UPLOADED, [
+            result.key
+        ], user, {
+            location,
+            storageConfigId: configId,
+            totalSize: result.size,
+            count: 1
+        });
         return {
             ...result,
             location,
@@ -174,6 +183,12 @@ export class UploadService {
         }
         const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
         const results = await provider.uploadMultipleFiles(files, options);
+        await this.publishFileEvent(STORAGE_EVENT_ACTIONS.UPLOADED, results.map((result)=>result.key), user, {
+            location,
+            storageConfigId: configId,
+            totalSize: results.reduce((sum, result)=>sum + (result.size ?? 0), 0),
+            count: results.length
+        });
         return results.map((result)=>({
                 ...result,
                 location,
@@ -187,6 +202,12 @@ export class UploadService {
         });
         const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
         await provider.deleteFile(key);
+        await this.publishFileEvent(STORAGE_EVENT_ACTIONS.REMOVED, [
+            key
+        ], user, {
+            storageConfigId,
+            count: 1
+        });
         return true;
     }
     async deleteMultipleFile(keys, storageConfigId, user, locationHint) {
@@ -196,8 +217,22 @@ export class UploadService {
         });
         const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
         await provider.deleteMultipleFiles(keys);
+        await this.publishFileEvent(STORAGE_EVENT_ACTIONS.REMOVED, keys, user, {
+            storageConfigId,
+            count: keys.length
+        });
         return true;
     }
+    async publishFileEvent(action, keys, user, metadata) {
+        await publishDomainEvent({
+            module: STORAGE_EVENT_MODULE,
+            entity: STORAGE_EVENT_ENTITIES.FILE,
+            action,
+            ids: keys,
+            metadata,
+            user: user ?? null
+        });
+    }
     bytesToKb(bytes) {
         return Number((bytes * 0.001).toFixed(2));
     }

package/fesm/services/upload.service.spec.js

@@ -1,4 +1,5 @@
 import { Test } from '@nestjs/testing';
+import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
 import { UploadService } from './upload.service';
 import { StorageFactoryService } from '../providers/storage-factory.service';
 import { StorageConfigService } from './storage-config.service';
@@ -365,4 +366,57 @@ describe('UploadService', ()=>{
             expect(mockProvider.generatePresignedUrl).toHaveBeenCalledWith('uploads/photo.jpg', 3600);
         });
     });
+    describe('domain events', ()=>{
+        let publish;
+        beforeEach(()=>{
+            publish = jest.fn().mockResolvedValue(undefined);
+            EventBusRegistry.reset();
+            EventBusRegistry.setBus({
+                publish,
+                subscribe: jest.fn(),
+                close: jest.fn()
+            });
+            EventBusRegistry.configureModule('storage', {
+                enabled: true
+            });
+            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
+                id: 'cfg-default',
+                storage: 'local',
+                config: {}
+            });
+        });
+        afterEach(()=>{
+            EventBusRegistry.reset();
+        });
+        it('publishes storage.file_manager.uploaded after a single upload', async ()=>{
+            await service.uploadSingleFile(buildMulterFile(), {}, buildMockUser());
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'storage.file_manager.uploaded',
+                payload: expect.objectContaining({
+                    metadata: expect.objectContaining({
+                        count: 1,
+                        storageConfigId: 'cfg-default'
+                    })
+                })
+            }));
+        });
+        it('publishes storage.file_manager.removed after a delete', async ()=>{
+            await service.deleteSingleFile('uploads/photo.jpg', 'cfg-1', buildMockUser());
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'storage.file_manager.removed',
+                payload: expect.objectContaining({
+                    ids: [
+                        'uploads/photo.jpg'
+                    ]
+                })
+            }));
+        });
+        it('does not publish when the storage module has events disabled', async ()=>{
+            EventBusRegistry.configureModule('storage', {
+                enabled: false
+            });
+            await service.uploadSingleFile(buildMulterFile(), {}, buildMockUser());
+            expect(publish).not.toHaveBeenCalled();
+        });
+    });
 });

package/interfaces/storage-module-options.interface.d.ts

@@ -1,4 +1,5 @@
 import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { IModuleEventsConfig } from '@flusys/nestjs-shared/interfaces';
 import { ModuleMetadata, Type } from '@nestjs/common';
 export interface IStorageModuleConfig extends IDataSourceServiceOptions {
     maxFileSize?: number;
@@ -6,6 +7,7 @@ export interface IStorageModuleConfig extends IDataSourceServiceOptions {
     defaultStorageProvider?: string;
     localStoragePath?: string;
     appUrl?: string;
+    events?: IModuleEventsConfig;
 }
 export interface StorageModuleOptions extends IDynamicModuleConfig {
     bootstrapAppConfig?: IBootstrapAppConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-storage",
-  "version": "6.4.1",
+  "version": "7.0.0-beta.1",
   "description": "Modular storage package with optional AWS S3, Azure Blob, and SFTP providers",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -129,7 +129,7 @@
     }
   },
   "dependencies": {
-    "@flusys/nestjs-core": "6.4.1",
-    "@flusys/nestjs-shared": "6.4.1"
+    "@flusys/nestjs-core": "7.0.0-beta.1",
+    "@flusys/nestjs-shared": "7.0.0-beta.1"
   }
 }

package/services/storage-provider-config.service.d.ts

@@ -1,7 +1,8 @@
 import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
+import { DeleteDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { EntityTarget, SelectQueryBuilder } from 'typeorm';
+import { EntityTarget, QueryRunner, SelectQueryBuilder } from 'typeorm';
 import { CreateStorageConfigDto, UpdateStorageConfigDto } from '../dtos';
 import { StorageConfig, StorageConfigBase } from '../entities';
 import { IStorageConfig } from '../interfaces';
@@ -13,6 +14,7 @@ export declare class StorageProviderConfigService extends ApiService<CreateStora
     private readonly storageConfig;
     constructor(cacheManager: HybridCache, utilsService: UtilsService, storageConfig: StorageConfigService, dataSourceProvider: StorageDataSourceProvider);
     protected resolveEntity(): EntityTarget<StorageConfigBase>;
+    protected beforeDeleteOperation(dto: DeleteDto, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
     convertSingleDtoToEntity(dto: CreateStorageConfigDto | UpdateStorageConfigDto, user: ILoggedUserInfo | null): Promise<StorageConfigBase>;
     getSelectQuery(query: SelectQueryBuilder<StorageConfigBase>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{
         query: SelectQueryBuilder<StorageConfig>;

package/services/upload.service.d.ts

@@ -18,6 +18,7 @@ export declare class UploadService {
     uploadMultipleFiles(files: Express.Multer.File[], options: UploadOptionsDto, user?: ILoggedUserInfo): Promise<IUploadedFileInfo[]>;
     deleteSingleFile(key: string, storageConfigId?: string, user?: ILoggedUserInfo, locationHint?: string): Promise<boolean>;
     deleteMultipleFile(keys: string[], storageConfigId?: string, user?: ILoggedUserInfo, locationHint?: string): Promise<boolean>;
+    private publishFileEvent;
     bytesToKb(bytes: number): number;
     getLocalStorageBasePath(): Promise<string | null>;
     makeFileUrl(key: string, storageConfigId: string, expiresIn?: number, user?: ILoggedUserInfo): Promise<string>;