@punks/backend-entity-manager 0.0.82 → 0.0.84

package/dist/cjs/index.js

@@ -14,6 +14,8 @@ var metadataScanner = require('@nestjs/core/metadata-scanner');
 var jwt = require('@nestjs/jwt');
 var eventEmitter = require('@nestjs/event-emitter');
 var typeorm = require('typeorm');
+var clientS3 = require('@aws-sdk/client-s3');
+var s3RequestPresigner = require('@aws-sdk/s3-request-presigner');
 var clientSes = require('@aws-sdk/client-ses');
 var require$$2 = require('fs');
 var mail = require('@sendgrid/mail');
@@ -22,6 +24,12 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
 
+exports.BucketItemType = void 0;
+(function (BucketItemType) {
+    BucketItemType["File"] = "file";
+    BucketItemType["Folder"] = "folder";
+})(exports.BucketItemType || (exports.BucketItemType = {}));
+
 class EntityManagerException extends Error {
     constructor(message) {
         super(message);
@@ -94,6 +102,13 @@ exports.SortDirection = void 0;
     SortDirection["Desc"] = "desc";
 })(exports.SortDirection || (exports.SortDirection = {}));
 
+exports.EntitySerializationFormat = void 0;
+(function (EntitySerializationFormat) {
+    EntitySerializationFormat["Csv"] = "csv";
+    EntitySerializationFormat["Json"] = "json";
+    EntitySerializationFormat["Xlsx"] = "xlsx";
+})(exports.EntitySerializationFormat || (exports.EntitySerializationFormat = {}));
+
 class EntitySeeder {
     constructor() {
         this.logger = backendCore.Log.getLogger(EntitySeeder.name);
@@ -113,6 +128,102 @@ class EntitySeeder {
     }
 }
 
+class EntitySerializer {
+    constructor(services) {
+        this.services = services;
+    }
+    async parse(data, format) {
+        throw new Error("Method not implemented.");
+    }
+    async createSample(format) {
+        return await this.buildSampleFile(format);
+    }
+    async buildSampleFile(format) {
+        const fileName = this.buildExportFileName({
+            format,
+            refDate: new Date(),
+        });
+        switch (format) {
+            case exports.EntitySerializationFormat.Csv:
+                return {
+                    fileName,
+                    contentType: "text/csv",
+                    content: Buffer.from(backendCore.csvBuild([{}], this.getDefinition().columns.map((c) => ({
+                        name: c.name,
+                        value: () => c.sampleValue ?? "",
+                    }))), "utf-8"),
+                };
+            case exports.EntitySerializationFormat.Xlsx:
+                return {
+                    fileName,
+                    contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                    content: Buffer.from(backendCore.excelBuild({
+                        data: [{}],
+                        sheetName: this.services.getEntityName(),
+                        columns: this.getDefinition().columns.map((c) => ({
+                            header: c.name,
+                            value: () => c.sampleValue ?? "",
+                            headerSize: c.colSpan,
+                        })),
+                    })),
+                };
+            case exports.EntitySerializationFormat.Json:
+                throw new Error("Json sample not implemented");
+        }
+    }
+    async serialize(data, format) {
+        return await this.buildExportFile(data, format);
+    }
+    async buildExportFile(data, format) {
+        const fileName = this.buildExportFileName({
+            format,
+            refDate: new Date(),
+        });
+        switch (format) {
+            case exports.EntitySerializationFormat.Csv:
+                return {
+                    fileName,
+                    contentType: "text/csv",
+                    content: Buffer.from(backendCore.csvBuild(data, this.getDefinition().columns.map((c) => ({
+                        name: c.name,
+                        value: (item) => this.getColumnValue(item, c),
+                    }))), "utf-8"),
+                };
+            case exports.EntitySerializationFormat.Xlsx:
+                return {
+                    fileName,
+                    contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                    content: Buffer.from(backendCore.excelBuild({
+                        data,
+                        sheetName: this.services.getEntityName(),
+                        columns: this.getDefinition().columns.map((c) => ({
+                            header: c.name,
+                            value: (item) => this.getColumnValue(item, c),
+                            headerSize: c.colSpan,
+                        })),
+                    })),
+                };
+            case exports.EntitySerializationFormat.Json:
+                return {
+                    fileName,
+                    contentType: "application/json",
+                    content: Buffer.from(JSON.stringify(data), "utf-8"),
+                };
+        }
+    }
+    getColumnValue(item, definition) {
+        const rawValue = item[definition.selector];
+        return definition.converter
+            ? definition.converter(rawValue, item)
+            : rawValue;
+    }
+    buildExportFileName(input) {
+        return `${input.refDate
+            .toISOString()
+            .replaceAll(":", "_")}_${this.services.getEntityName()}.${input.format}`;
+    }
+}
+
 const PLATFORM_EVENT_NAMESPACE = "platform";
 const PlatformEvents = {
     Messaging: {
@@ -151,6 +262,12 @@ class NestEntityManager {
     }
 }
 
+class NestEntitySerializer extends EntitySerializer {
+    constructor(services) {
+        super(services);
+    }
+}
+
 const EntityManagerSymbols = {
     AppInitializer: Symbol.for("WP:APP_INITIALIZER"),
     EventsTracker: Symbol.for("WP:EVENTS_TRACKER"),
@@ -161,11 +278,13 @@ const EntityManagerSymbols = {
     EntityRepository: Symbol.for("WP:ENTITY_REPOSITORY"),
     EntityConnector: Symbol.for("WP:ENTITY_CONNECTOR"),
     EntityConverter: Symbol.for("WP:ENTITY_CONVERTER"),
+    EntitySerializer: Symbol.for("WP:ENTITY_SERIALIZER"),
     EntityManager: Symbol.for("WP:ENTITY_MANAGER"),
     EntityQueryBuilder: Symbol.for("WP:ENTITY_QUERY_BUILDER"),
     EntitySeeder: Symbol.for("WP:ENTITY_SEEDER"),
     EmailProvider: Symbol.for("WP:EMAIL_PROVIDER"),
     EmailTemplate: Symbol.for("WP:EMAIL_TEMPLATE"),
+    BucketProvider: Symbol.for("WP:BUCKET_PROVIDER"),
     PipelineTemplate: Symbol.for("WP:PIPELINE_TEMPLATE"),
 };
 
@@ -174,6 +293,10 @@ const WpEntityAuthMiddleware = (entityName, props = {}) => common.applyDecorator
     ...props,
 }));
 
+const WpBucketProvider = (providerId) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.BucketProvider, {
+    providerId,
+}));
+
 const WpEntityActions = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityActions, {
     entityName,
     ...props,
@@ -233,6 +356,11 @@ const WpEntitySeeder = (entityName, props = {}) => common.applyDecorators(common
     ...props,
 }));
 
+const WpEntitySerializer = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntitySerializer, {
+    entityName,
+    ...props,
+}));
+
 const WpEventsTracker = (props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EventsTracker, {
     ...props,
 }));
@@ -546,6 +674,19 @@ class EntityExistsAction {
     }
 }
 
+class EntitiesExportAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Export`);
+    }
+    async execute(input) {
+        this.logger.debug("Export action started", { input });
+        const result = await this.services.resolveExportCommand().execute(input);
+        this.logger.debug("Export action completed", { input });
+        return result;
+    }
+}
+
 class EntityGetAction {
     constructor(services) {
         this.services = services;
@@ -559,6 +700,34 @@ class EntityGetAction {
     }
 }
 
+class EntitiesImportAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Import`);
+    }
+    async execute(input) {
+        this.logger.debug("Import action started", { input });
+        const result = await this.services.resolveImportCommand().execute(input);
+        this.logger.debug("Import action completed", { input });
+        return result;
+    }
+}
+
+class EntitiesSampleDownloadAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Import`);
+    }
+    async execute(input) {
+        this.logger.debug("Import action started", { input });
+        const result = await this.services
+            .resolveSampleDownloadCommand()
+            .execute(input);
+        this.logger.debug("Import action completed", { input });
+        return result;
+    }
+}
+
 class EntitiesSearchAction {
     constructor(services) {
         this.services = services;
@@ -717,6 +886,83 @@ class EntitiesDeleteCommand {
     }
 }
 
+const createDayPath = (d) => `${d.getFullYear()}/${(d.getMonth() + 1).toString().padStart(2, "0")}/${d
+    .getDate()
+    .toString()
+    .padStart(2, "0")}`;
+class EntitiesExportCommand {
+    constructor(services, settings) {
+        this.services = services;
+        this.settings = settings;
+    }
+    async execute(input) {
+        const exportEntities = await this.getExportEntities(input.filters);
+        const outputFile = await this.buildExportFile(exportEntities.items, input.options.format);
+        const downloadUrl = await this.uploadExportFile(outputFile);
+        return {
+            downloadUrl,
+            file: {
+                content: outputFile.content,
+                contentType: outputFile.contentType,
+                name: outputFile.fileName,
+            },
+        };
+    }
+    async buildExportFile(data, format) {
+        return await this.services.resolveSerializer().serialize(data, format);
+    }
+    async uploadExportFile(file) {
+        await this.bucket.fileUpload({
+            bucket: this.settings.exportBucket.bucket,
+            filePath: this.buildAbsoluteBucketPath(file.fileName),
+            content: file.content,
+            contentType: file.contentType,
+        });
+        return await this.bucket.filePublicUrlCreate({
+            bucket: this.settings.exportBucket.bucket,
+            expirationMinutes: this.settings.exportBucket.publicLinksExpirationMinutes,
+            filePath: this.buildAbsoluteBucketPath(file.fileName),
+        });
+    }
+    buildAbsoluteBucketPath(relativePath) {
+        return `${this.settings.exportBucket.rootFolderPath ?? ""}/${createDayPath(new Date())}/${relativePath}`;
+    }
+    async getExportEntities(filters) {
+        return this.services.resolveSearchQuery().execute(filters ?? {});
+    }
+    get bucket() {
+        return this.services.getRootServices().resolveBucketProvider();
+    }
+}
+
+class EntitiesImportCommand {
+    constructor(services, settings) {
+        this.services = services;
+        this.settings = settings;
+    }
+    execute(input) {
+        throw new Error("Method not implemented.");
+    }
+}
+
+class EntitiesSampleDownloadCommand {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(input) {
+        const sample = await this.services
+            .resolveSerializer()
+            .createSample(input.format);
+        return {
+            file: {
+                content: sample.content,
+                contentType: sample.contentType,
+                name: sample.fileName,
+            },
+        };
+    }
+}
+
 class EntityUpdateCommand {
     constructor(services) {
         this.services = services;
@@ -834,6 +1080,15 @@ class EntityManager {
     get delete() {
         return this.services.resolveDeleteCommand();
     }
+    get export() {
+        return this.services.resolveExportCommand();
+    }
+    get import() {
+        return this.services.resolveImportCommand();
+    }
+    get sampleDownload() {
+        return this.services.resolveSampleDownloadCommand();
+    }
 }
 class EntityActions {
     constructor(services) {
@@ -866,6 +1121,15 @@ class EntityActions {
     get delete() {
         return this.services.resolveDeleteAction();
     }
+    get export() {
+        return this.services.resolveExportAction();
+    }
+    get import() {
+        return this.services.resolveImportAction();
+    }
+    get sampleDownload() {
+        return this.services.resolveSampleDownloadAction();
+    }
 }
 
 // todo: implement a real IoC container with scopes and stuff
@@ -918,6 +1182,9 @@ const EntityServices = {
         IEntityUpsertAction: "IEntityUpsertAction",
         IEntityDeleteAction: "IEntityDeleteAction",
         IEntityMergeAction: "IEntityMergeAction",
+        IEntitiesExportAction: "IEntitiesExportAction",
+        IEntitiesImportAction: "IEntitiesImportAction",
+        IEntitiesSampleDownloadAction: "IEntitiesSampleDownloadAction",
     },
     Authorization: {
         IEntityAuthorizationMiddleware: "IEntityAuthorizationMiddleware",
@@ -929,10 +1196,14 @@ const EntityServices = {
         IEntityMergeCommand: "IEntityMergeCommand",
         IEntityDeleteCommand: "IEntityDeleteCommand",
         IEntitiesDeleteCommand: "IEntitiesDeleteCommand",
+        IEntitiesExportCommand: "IEntitiesExportCommand",
+        IEntitiesImportCommand: "IEntitiesImportCommand",
+        IEntitiesSampleDownloadCommand: "IEntitiesSampleDownloadCommand",
     },
     Converters: {
         IEntityAdapter: "IEntityAdapter",
         IEntityConverter: "IEntityConverter",
+        IEntitySerializer: "IEntitySerializer",
     },
     Connectors: {
         IConnectorsConfiguration: "IConnectorsConfiguration",
@@ -970,13 +1241,14 @@ const GlobalServices = {
     Authentication: {
         IAuthenticationContextProvider: "IAuthenticationContextProvider",
     },
-    Messaging: {
-        IEmailProvider: "IEmailProvider",
-        IEmailTemplatesCollection: "IEmailTemplatesCollection",
-    },
     Pipelines: {
         IPipelineController: "IPipelineController",
     },
+    Plugins: {
+        IEmailProvider: "IEmailProvider",
+        IEmailTemplatesCollection: "IEmailTemplatesCollection",
+        IBucketProvider: "IBucketProvider",
+    },
 };
 
 class EntityServiceLocator {
@@ -1023,6 +1295,9 @@ class EntityServiceLocator {
     resolveConverter() {
         return this.services.resolveConverter(this.entityName);
     }
+    resolveSerializer() {
+        return this.services.resolveSerializer(this.entityName);
+    }
     resolveAdapter() {
         return this.services.resolveAdapter(this.entityName);
     }
@@ -1050,15 +1325,21 @@ class EntityServiceLocator {
     resolveUpsertCommand() {
         return this.services.resolveUpsertCommand(this.entityName);
     }
-    // resolveMergeCommand(): IEntityMergeCommand<TEntity> {
-    //   return this.services.resolveMergeCommand<TEntity>(this.entityName)
-    // }
     resolveDeleteCommand() {
         return this.services.resolveDeleteCommand(this.entityName);
     }
     resolveDeleteItemsCommand() {
         return this.services.resolveDeleteItemsCommand(this.entityName);
     }
+    resolveSampleDownloadCommand() {
+        return this.services.resolveSampleDownloadCommand(this.entityName);
+    }
+    resolveImportCommand() {
+        return this.services.resolveImportCommand(this.entityName);
+    }
+    resolveExportCommand() {
+        return this.services.resolveExportCommand(this.entityName);
+    }
     resolveGetAction() {
         return this.services.resolveGetAction(this.entityName);
     }
@@ -1086,6 +1367,15 @@ class EntityServiceLocator {
     resolveDeleteItemsAction() {
         return this.services.resolveDeleteItemsAction(this.entityName);
     }
+    resolveImportAction() {
+        return this.services.resolveImportAction(this.entityName);
+    }
+    resolveSampleDownloadAction() {
+        return this.services.resolveSampleDownloadAction(this.entityName);
+    }
+    resolveExportAction() {
+        return this.services.resolveExportAction(this.entityName);
+    }
     resolveQueryBuilder() {
         return this.services.resolveQueryBuilder(this.entityName);
     }
@@ -1109,10 +1399,16 @@ class EntitiesServiceLocator {
         this.provider.register(GlobalServices.Events.IEventEmitter, instance);
     }
     resolveEmailProvider() {
-        return this.provider.resolve(GlobalServices.Messaging.IEmailProvider);
+        return this.provider.resolve(GlobalServices.Plugins.IEmailProvider);
     }
     registerEmailProvider(instance) {
-        this.provider.register(GlobalServices.Messaging.IEmailProvider, instance);
+        this.provider.register(GlobalServices.Plugins.IEmailProvider, instance);
+    }
+    resolveBucketProvider() {
+        return this.provider.resolve(GlobalServices.Plugins.IBucketProvider);
+    }
+    registerBucketProvider(instance) {
+        this.provider.register(GlobalServices.Plugins.IBucketProvider, instance);
     }
     resolveEventsTracker() {
         return this.provider.resolve(GlobalServices.Events.IEventsTracker);
@@ -1121,10 +1417,10 @@ class EntitiesServiceLocator {
         this.provider.register(GlobalServices.Events.IEventsTracker, instance);
     }
     resolveEmailTemplatesCollection() {
-        return this.provider.resolve(GlobalServices.Messaging.IEmailTemplatesCollection);
+        return this.provider.resolve(GlobalServices.Plugins.IEmailTemplatesCollection);
     }
     registerEmailTemplatesCollection(instance) {
-        this.provider.register(GlobalServices.Messaging.IEmailTemplatesCollection, instance);
+        this.provider.register(GlobalServices.Plugins.IEmailTemplatesCollection, instance);
     }
     resolvePipelinesController() {
         return this.provider.resolve(GlobalServices.Pipelines.IPipelineController);
@@ -1216,6 +1512,12 @@ class EntitiesServiceLocator {
             optional: true,
         });
     }
+    registerSerializer(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Converters.IEntitySerializer, entityName, instance);
+    }
+    resolveSerializer(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Converters.IEntitySerializer, entityName);
+    }
     resolveAuthorizationMiddleware(entityName) {
         return this.provider.resolveEntityService(EntityServices.Authorization.IEntityAuthorizationMiddleware, entityName, {
             optional: true,
@@ -1272,40 +1574,30 @@ class EntitiesServiceLocator {
     registerDeleteItemsCommand(entityName, instance) {
         this.provider.registerEntityService(EntityServices.Commands.IEntitiesDeleteCommand, entityName, instance);
     }
-    // resolveMergeCommand<TEntity>(
-    //   entityName: string
-    // ): IEntityMergeCommand<TEntity> {
-    //   return this.provider.resolveEntityService<IEntityMergeCommand<TEntity>>(
-    //     Services.Commands.IEntityMergeCommand,
-    //     entityName
-    //   )
-    // }
-    // registerMergeCommand<TEntity>(
-    //   entityName: string,
-    //   instance: IEntityMergeCommand<TEntity>
-    // ) {
-    //   this.provider.registerEntityService<IEntityMergeCommand<TEntity>>(
-    //     Services.Commands.IEntityMergeCommand,
-    //     entityName,
-    //     instance
-    //   )
-    // }
-    // registerMergeAction<TEntity>(
-    //   entityName: string,
-    //   instance: IEntityMergeAction<TEntity>
-    // ) {
-    //   this.provider.registerEntityService<IEntityMergeAction<TEntity>>(
-    //     Services.Actions.IEntityMergeAction,
-    //     entityName,
-    //     instance
-    //   )
-    // }
     resolveDeleteCommand(entityName) {
         return this.provider.resolveEntityService(EntityServices.Commands.IEntityDeleteCommand, entityName);
     }
     registerDeleteCommand(entityName, instance) {
         this.provider.registerEntityService(EntityServices.Commands.IEntityDeleteCommand, entityName, instance);
     }
+    resolveExportCommand(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Commands.IEntitiesExportCommand, entityName);
+    }
+    registerExportCommand(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Commands.IEntitiesExportCommand, entityName, instance);
+    }
+    resolveImportCommand(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Commands.IEntitiesImportCommand, entityName);
+    }
+    registerImportCommand(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Commands.IEntitiesImportCommand, entityName, instance);
+    }
+    resolveSampleDownloadCommand(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Commands.IEntitiesSampleDownloadCommand, entityName);
+    }
+    registerSampleDownloadCommand(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Commands.IEntitiesSampleDownloadCommand, entityName, instance);
+    }
     resolveGetAction(entityName) {
         return this.provider.resolveEntityService(EntityServices.Actions.IEntityGetAction, entityName);
     }
@@ -1360,6 +1652,24 @@ class EntitiesServiceLocator {
     registerDeleteItemsAction(entityName, instance) {
         this.provider.registerEntityService(EntityServices.Actions.IEntitiesDeleteAction, entityName, instance);
     }
+    resolveExportAction(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Actions.IEntitiesExportAction, entityName);
+    }
+    registerExportAction(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Actions.IEntitiesExportAction, entityName, instance);
+    }
+    resolveSampleDownloadAction(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Actions.IEntitiesSampleDownloadAction, entityName);
+    }
+    registerSampleDownloadAction(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Actions.IEntitiesSampleDownloadAction, entityName, instance);
+    }
+    resolveImportAction(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Actions.IEntitiesImportAction, entityName);
+    }
+    registerImportAction(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Actions.IEntitiesImportAction, entityName, instance);
+    }
     resolveQueryBuilder(entityName) {
         return this.provider.resolveEntityService(EntityServices.Queries.IEntitiesQueryBuilder, entityName);
     }
@@ -1753,7 +2063,7 @@ class EntityManagerServiceCollection {
     getServiceLocator() {
         return this.resolver;
     }
-    mapCrudOperations({ queryBuilder, }) {
+    mapCrudOperations({ queryBuilder, settings, }) {
         this.mapGet();
         this.mapCount();
         this.mapExists();
@@ -1763,6 +2073,7 @@ class EntityManagerServiceCollection {
         this.mapCreate();
         this.mapUpdate();
         this.mapDelete();
+        this.mapImportExport(settings.importExport);
         return this;
     }
     mapGet() {
@@ -1791,15 +2102,16 @@ class EntityManagerServiceCollection {
         this.locator.registerCreateAction(this.entityName, new EntityCreateAction(this.resolver));
         return this;
     }
+    mapImportExport(settings) {
+        this.locator.registerExportCommand(this.entityName, new EntitiesExportCommand(this.resolver, settings));
+        this.locator.registerExportAction(this.entityName, new EntitiesExportAction(this.resolver));
+        this.locator.registerImportCommand(this.entityName, new EntitiesImportCommand(this.resolver, settings));
+        this.locator.registerImportAction(this.entityName, new EntitiesImportAction(this.resolver));
+        this.locator.registerSampleDownloadCommand(this.entityName, new EntitiesSampleDownloadCommand(this.resolver));
+        this.locator.registerSampleDownloadAction(this.entityName, new EntitiesSampleDownloadAction(this.resolver));
+        return this;
+    }
     mapUpdate() {
-        // this.locator.registerMergeCommand(
-        //   this.entityName,
-        //   new EntityMergeCommand(this.resolver)
-        // )
-        // this.locator.registerMergeAction(
-        //   this.entityName,
-        //   new EntityMergeAction(this.resolver)
-        // )
         this.locator.registerUpsertCommand(this.entityName, new EntityUpsertCommand(this.resolver));
         this.locator.registerUpsertAction(this.entityName, new EntityUpsertAction(this.resolver));
         this.locator.registerUpdateCommand(this.entityName, new EntityUpdateCommand(this.resolver));
@@ -1810,13 +2122,17 @@ class EntityManagerServiceCollection {
         this.locator.registerDeleteCommand(this.entityName, new EntityDeleteCommand(this.resolver));
         this.locator.registerDeleteAction(this.entityName, new EntityDeleteAction(this.resolver));
         this.locator.registerDeleteItemsCommand(this.entityName, new EntitiesDeleteCommand(this.resolver));
-        this.locator.registerDeleteAction(this.entityName, new EntitiesDeleteAction(this.resolver));
+        this.locator.registerDeleteItemsAction(this.entityName, new EntitiesDeleteAction(this.resolver));
         return this;
     }
     addAdapter(adapter) {
         this.locator.registerAdapter(this.entityName, adapter);
         return this;
     }
+    addSerializer(serializer) {
+        this.locator.registerSerializer(this.entityName, serializer);
+        return this;
+    }
     addConverter(converter) {
         this.locator.registerConverter(this.entityName, converter);
         return this;
@@ -1850,18 +2166,24 @@ exports.EntityManagerRegistry = class EntityManagerRegistry {
                 .registerEventEmitter(eventEmitter);
         }
     }
-    async registerDiscoveredEntity(app, { adapter, entityName, converter, queryBuilder, repository, authMiddleware, }) {
+    async registerDiscoveredEntity(app, { adapter, entityName, converter, queryBuilder, repository, authMiddleware, serializer, settings, }) {
         if (!repository.discoveredClass.injectType) {
             throw new Error(`No inject type found for entity repository: ${entityName}`);
         }
         const repositoryInstance = (await app.resolve(repository.discoveredClass.injectType));
         const registration = this.container.registerEntity(entityName, repositoryInstance);
+        if (!serializer?.discoveredClass?.injectType) {
+            throw new Error(`No inject type found for entity serializer: ${entityName}`);
+        }
+        const serializerInstance = (await app.resolve(serializer.discoveredClass.injectType));
+        registration.addSerializer(serializerInstance);
         if (!queryBuilder.discoveredClass.injectType) {
             throw new Error(`No inject type found for entity query builder: ${entityName}`);
         }
         const queryBuilderInstance = (await app.resolve(queryBuilder.discoveredClass.injectType));
         registration.mapCrudOperations({
             queryBuilder: queryBuilderInstance,
+            settings,
         });
         const converterInstance = converter?.discoveredClass.injectType
             ? (await app.resolve(converter.discoveredClass.injectType))
@@ -20399,7 +20721,7 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             eventEmitter: this.eventEmitter,
         });
         this.logger.log("Initializing entity manager types 🥁");
-        await this.registerEntities(app);
+        await this.registerEntities(app, staticProviders);
         if (staticProviders.authenticationProvider) {
             await this.registerAuthentication(staticProviders.authenticationProvider);
             this.logger.log("Entity manager authentication initialized 🔑");
@@ -20417,14 +20739,16 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             provider: authenticationProvider,
         });
     }
-    async registerEntities(app) {
+    async registerEntities(app, staticProviders) {
         const repositories = await this.discoverRepositories();
         const queryBuilders = await this.discoverQueryBuilders();
         const converters = await this.discoverConverters();
+        const serializers = await this.discoverSerializers();
         const adapters = await this.discoverAdapters();
         const auth = await this.discoverAuthMiddlewares();
         const queryBuilderDict = backendCore.toDict(queryBuilders, (q) => q.meta.entityName);
         const converterDict = backendCore.toDict(converters, (c) => c.meta.entityName);
+        const serializerDict = backendCore.toDict(serializers, (s) => s.meta.entityName);
         const adapterDict = backendCore.toDict(adapters, (a) => a.meta.entityName);
         const authDict = backendCore.toDict(auth, (a) => a.meta.entityName);
         const sortedRepositories = lodash.exports.orderBy(repositories, (x) => x.meta.entityName);
@@ -20438,19 +20762,23 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             const converter = converterDict[entityName];
             const adapter = adapterDict[entityName];
             const authMiddleware = authDict[entityName];
+            const serializer = serializerDict[entityName];
             await this.registry.registerDiscoveredEntity(app, {
                 entityName,
                 adapter,
                 repository,
                 queryBuilder,
                 converter,
+                serializer,
                 authMiddleware,
+                settings: staticProviders.settings,
             });
             this.logger.log(`Entity ${entityName} registered:
   - Repository: ${repository.discoveredClass.injectType?.name ?? ""}
   - Query builder: ${queryBuilder.discoveredClass.injectType?.name ?? ""}
   - Adapter: ${adapter?.discoveredClass.injectType?.name ?? ""}
   - Converter: ${converter?.discoveredClass.injectType?.name ?? ""}
+  - Serializer: ${serializer?.discoveredClass.injectType?.name ?? ""}
   - Auth middleware: ${authMiddleware?.discoveredClass.injectType?.name ?? ""}
 ✨
       `);
@@ -20531,6 +20859,9 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
     async discoverConverters() {
         return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityConverter);
     }
+    async discoverSerializers() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntitySerializer);
+    }
     async discoverAdapters() {
         return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityAdapter);
     }
@@ -20858,7 +21189,7 @@ AuthenticationMiddleware = __decorate([
 ], AuthenticationMiddleware);
 
 var AuthenticationModule_1;
-const ModuleData$2 = {
+const ModuleData$3 = {
     imports: [exports.EntityManagerModule, jwt.JwtModule],
     providers: [
         AuthenticationServicesResolver,
@@ -20875,7 +21206,7 @@ exports.AuthenticationModule = AuthenticationModule_1 = class AuthenticationModu
         authSettings.initialize(input);
         return {
             module: AuthenticationModule_1,
-            ...ModuleData$2,
+            ...ModuleData$3,
         };
     }
     configure(consumer) {
@@ -20888,7 +21219,7 @@ exports.AuthenticationModule = AuthenticationModule_1 = class AuthenticationModu
 };
 exports.AuthenticationModule = AuthenticationModule_1 = __decorate([
     common.Module({
-        ...ModuleData$2,
+        ...ModuleData$3,
     })
 ], exports.AuthenticationModule);
 
@@ -21362,6 +21693,207 @@ class NestPipelineTemplate {
     }
 }
 
+class AwsS2BucketError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AwsS2BucketError";
+    }
+}
+
+const awsBucketSettings = new AppInMemorySettings();
+
+const createClient$1 = (settings) => new clientS3.S3Client({
+    region: settings.region,
+    credentials: settings.awsAccessKeyId && settings.awsSecretAccessKey
+        ? {
+            accessKeyId: settings.awsAccessKeyId,
+            secretAccessKey: settings.awsSecretAccessKey,
+        }
+        : undefined,
+});
+exports.AwsS3BucketProvider = class AwsS3BucketProvider {
+    constructor() {
+        this.client = createClient$1(awsBucketSettings.value);
+    }
+    async folderList(input) {
+        try {
+            return await this.client.send(new clientS3.ListObjectsCommand({
+                Bucket: input.bucket,
+                MaxKeys: input.maxResults,
+                Prefix: input.path,
+            }));
+        }
+        catch (e) {
+            throw new AwsS2BucketError(`AWS BUCKET | listObjectsV2 | ${input.bucket} | ${input.path} | Error -> ${e.message}`);
+        }
+    }
+    async folderEnsure(input) {
+        if (await this.folderExists(input)) {
+            return;
+        }
+        await this.folderCreate(input);
+    }
+    async folderCreate(input) {
+        try {
+            await this.client.send(new clientS3.PutObjectCommand({
+                Bucket: input.bucket,
+                Key: backendCore.ensureTailingSlash(input.path),
+            }));
+        }
+        catch (e) {
+            throw new AwsS2BucketError(`AwsS3Bucket | folderCreate | ${input.bucket} | ${input.path} | Error -> ${e.message}`);
+        }
+    }
+    async folderExists(input) {
+        try {
+            const result = await this.client.send(new clientS3.GetObjectCommand({
+                Bucket: input.bucket,
+                Key: backendCore.ensureTailingSlash(input.path),
+            }));
+            return (result.ContentLength ?? 0) > 0;
+        }
+        catch (e) {
+            throw new AwsS2BucketError(`AwsS3Bucket | folderExists | Error -> ${e.message}`);
+        }
+    }
+    async fileDownload(input) {
+        try {
+            const result = await this.client.send(new clientS3.GetObjectCommand({
+                Bucket: input.bucket,
+                Key: input.filePath,
+            }));
+            return result.Body;
+        }
+        catch (e) {
+            throw new AwsS2BucketError(`AWS BUCKET | downloadFile | ${input.bucket} | ${input.filePath} | Error -> ${e.message}`);
+        }
+    }
+    async filePublicUrlCreate(input) {
+        try {
+            return await s3RequestPresigner.getSignedUrl(this.client, new clientS3.GetObjectCommand({
+                Bucket: input.bucket,
+                Key: input.filePath,
+            }), {
+                expiresIn: input.expirationMinutes * 60,
+            });
+        }
+        catch (e) {
+            throw new AwsS2BucketError(`AwsS3Bucket | filePublicUrlCreate | ${input.bucket} | ${input.filePath} | Error -> ${e.message}`);
+        }
+    }
+    async fileUpload(input) {
+        try {
+            await this.client.send(new clientS3.PutObjectCommand({
+                Bucket: input.bucket,
+                Key: input.filePath,
+                Body: input.content,
+                ContentType: input.contentType,
+            }));
+        }
+        catch (e) {
+            throw new AwsS2BucketError(`AwsS3Bucket | fileUpload | ${input.bucket} | ${input.filePath} | Error -> ${e.message}`);
+        }
+    }
+    async fileDelete(input) {
+        try {
+            await this.client.send(new clientS3.DeleteObjectCommand({
+                Bucket: input.bucket,
+                Key: input.filePath,
+            }));
+        }
+        catch (e) {
+            throw new AwsS2BucketError(`AwsS3Bucket | fileDelete | ${input.bucket} | ${input.filePath} | Error -> ${e.message}`);
+        }
+    }
+};
+exports.AwsS3BucketProvider = __decorate([
+    WpBucketProvider("awsS3"),
+    __metadata("design:paramtypes", [])
+], exports.AwsS3BucketProvider);
+
+var AwsBucketModule_1;
+const ModuleData$2 = {
+    providers: [exports.AwsS3BucketProvider],
+};
+exports.AwsBucketModule = AwsBucketModule_1 = class AwsBucketModule {
+    static forRoot(input) {
+        awsBucketSettings.initialize(input);
+        return {
+            module: AwsBucketModule_1,
+            ...ModuleData$2,
+        };
+    }
+};
+exports.AwsBucketModule = AwsBucketModule_1 = __decorate([
+    common.Module({
+        ...ModuleData$2,
+    })
+], exports.AwsBucketModule);
+
+exports.InMemoryBucketProvider = class InMemoryBucketProvider {
+    constructor() {
+        this.inMemoryStorage = {};
+        this.inMemoryFolders = {};
+    }
+    async folderList(input) {
+        // Implement folderList logic here
+        // You may need to filter and return folder contents from inMemoryStorage
+        const folderContents = [];
+        // Your implementation to populate folderContents goes here
+        return { items: folderContents };
+    }
+    async folderEnsure(input) {
+        // Implement folderEnsure logic here
+        // You may need to create a folder in inMemoryStorage
+        // based on the input bucket and path
+        const folderKey = `${input.bucket}/${input.path}`;
+        // Mock the folder creation
+        this.inMemoryFolders[folderKey] = true;
+    }
+    async folderExists(input) {
+        // Implement folderExists logic here
+        // Check if the folder exists in inMemoryStorage
+        const folderKey = `${input.bucket}/${input.path}`;
+        return !!this.inMemoryFolders[folderKey];
+    }
+    async fileDownload(input) {
+        // Implement fileDownload logic here
+        // Retrieve the file content from inMemoryStorage based on the filePath
+        const fileKey = `${input.bucket}/${input.filePath}`;
+        // Mock the file download
+        const fileContent = this.inMemoryStorage[fileKey];
+        if (!fileContent) {
+            throw new Error(`File not found: ${fileKey}`);
+        }
+        return fileContent;
+    }
+    async filePublicUrlCreate(input) {
+        // Implement filePublicUrlCreate logic here
+        // Generate a public URL for the file based on the input parameters
+        const fileKey = `${input.bucket}/${input.filePath}`;
+        // Mock the public URL creation
+        const publicUrl = `fs://${fileKey}`;
+        return publicUrl;
+    }
+    async fileUpload(input) {
+        // Implement fileUpload logic here
+        // Upload the file content to inMemoryStorage based on the bucket and filePath
+        const fileKey = `${input.bucket}/${input.filePath}`;
+        // Mock the file upload
+        this.inMemoryStorage[fileKey] = input.content;
+    }
+    async fileDelete(input) {
+        // Implement fileDelete logic here
+        // Delete the file from inMemoryStorage based on the bucket and filePath
+        const fileKey = `${input.bucket}/${input.filePath}`;
+        // Mock the file deletion
+        delete this.inMemoryStorage[fileKey];
+    }
+};
+exports.InMemoryBucketProvider = __decorate([
+    WpBucketProvider("in-memory")
+], exports.InMemoryBucketProvider);
+
 const AwsSesModuleSymbols = {
     EmailTemplate: Symbol.for("WP.PLG:AWS_SES.EMAIL_TEMPLATE"),
 };
@@ -26609,6 +27141,7 @@ exports.AuthenticationEmailTemplates = AuthenticationEmailTemplates;
 exports.AuthenticationError = AuthenticationError;
 exports.AuthenticationEvents = AuthenticationEvents;
 exports.AuthenticationExtensionSymbols = AuthenticationExtensionSymbols;
+exports.AwsS2BucketError = AwsS2BucketError;
 exports.AwsSesEmailTemplate = AwsSesEmailTemplate;
 exports.BooleanFacet = BooleanFacet;
 exports.BooleanFacetItem = BooleanFacetItem;
@@ -26619,6 +27152,7 @@ exports.EntityManagerUnauthorizedException = EntityManagerUnauthorizedException;
 exports.EntityNotFoundException = EntityNotFoundException;
 exports.EntityOperationUnauthorizedException = EntityOperationUnauthorizedException;
 exports.EntitySeeder = EntitySeeder;
+exports.EntitySerializer = EntitySerializer;
 exports.InvalidCredentialsError = InvalidCredentialsError;
 exports.MemberOf = MemberOf;
 exports.MissingEntityIdError = MissingEntityIdError;
@@ -26626,6 +27160,7 @@ exports.MultipleEntitiesFoundException = MultipleEntitiesFoundException;
 exports.NestEntityActions = NestEntityActions;
 exports.NestEntityAuthorizationMiddleware = NestEntityAuthorizationMiddleware;
 exports.NestEntityManager = NestEntityManager;
+exports.NestEntitySerializer = NestEntitySerializer;
 exports.NestPipelineTemplate = NestPipelineTemplate;
 exports.NestTypeOrmEntitySeeder = NestTypeOrmEntitySeeder;
 exports.NestTypeOrmQueryBuilder = NestTypeOrmQueryBuilder;
@@ -26644,6 +27179,7 @@ exports.StringFacet = StringFacet;
 exports.StringFacetItem = StringFacetItem;
 exports.WpAppInitializer = WpAppInitializer;
 exports.WpAwsSesEmailTemplate = WpAwsSesEmailTemplate;
+exports.WpBucketProvider = WpBucketProvider;
 exports.WpEmailTemplate = WpEmailTemplate;
 exports.WpEntity = WpEntity;
 exports.WpEntityActions = WpEntityActions;
@@ -26655,6 +27191,7 @@ exports.WpEntityManager = WpEntityManager;
 exports.WpEntityQueryBuilder = WpEntityQueryBuilder;
 exports.WpEntityRepository = WpEntityRepository;
 exports.WpEntitySeeder = WpEntitySeeder;
+exports.WpEntitySerializer = WpEntitySerializer;
 exports.WpEventsTracker = WpEventsTracker;
 exports.WpPipeline = WpPipeline;
 exports.WpRolesService = WpRolesService;