@punks/backend-entity-manager 0.0.83 → 0.0.85

package/dist/esm/index.js

@@ -1,5 +1,5 @@
-import { Log, isNullOrUndefined, sort, byField, toDict, newUuid as newUuid$1, removeUndefinedProps } from '@punks/backend-core';
-import { applyDecorators, Injectable, SetMetadata, Global, Module, Scope, Logger, HttpException, HttpStatus } from '@nestjs/common';
+import { Log, excelBuild, csvBuild, isNullOrUndefined, sort, byField, toDict, newUuid as newUuid$1, ensureTailingSlash, removeUndefinedProps } from '@punks/backend-core';
+import { applyDecorators, Injectable, SetMetadata, Global, Module, Scope, Logger, StreamableFile, HttpException, HttpStatus } from '@nestjs/common';
 import { ApiProperty } from '@nestjs/swagger';
 import { Reflector } from '@nestjs/core';
 import { AsyncLocalStorage } from 'async_hooks';
@@ -9,11 +9,19 @@ import { STATIC_CONTEXT } from '@nestjs/core/injector/constants';
 import { MetadataScanner } from '@nestjs/core/metadata-scanner';
 import { JwtService, JwtModule } from '@nestjs/jwt';
 import { EventEmitter2, EventEmitterModule } from '@nestjs/event-emitter';
+import require$$2, { createReadStream } from 'fs';
 import { In } from 'typeorm';
+import { ListObjectsCommand, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { SendEmailCommand, SESClient } from '@aws-sdk/client-ses';
-import require$$2 from 'fs';
 import { MailService } from '@sendgrid/mail';
 
+var BucketItemType;
+(function (BucketItemType) {
+    BucketItemType["File"] = "file";
+    BucketItemType["Folder"] = "folder";
+})(BucketItemType || (BucketItemType = {}));
+
 class EntityManagerException extends Error {
     constructor(message) {
         super(message);
@@ -86,6 +94,13 @@ var SortDirection;
     SortDirection["Desc"] = "desc";
 })(SortDirection || (SortDirection = {}));
 
+var EntitySerializationFormat;
+(function (EntitySerializationFormat) {
+    EntitySerializationFormat["Csv"] = "csv";
+    EntitySerializationFormat["Json"] = "json";
+    EntitySerializationFormat["Xlsx"] = "xlsx";
+})(EntitySerializationFormat || (EntitySerializationFormat = {}));
+
 class EntitySeeder {
     constructor() {
         this.logger = Log.getLogger(EntitySeeder.name);
@@ -105,6 +120,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 EntitySerializationFormat.Csv:
+                return {
+                    fileName,
+                    contentType: "text/csv",
+                    content: Buffer.from(csvBuild([{}], this.getDefinition().columns.map((c) => ({
+                        name: c.name,
+                        value: () => c.sampleValue ?? "",
+                    }))), "utf-8"),
+                };
+            case EntitySerializationFormat.Xlsx:
+                return {
+                    fileName,
+                    contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                    content: Buffer.from(excelBuild({
+                        data: [{}],
+                        sheetName: this.services.getEntityName(),
+                        columns: this.getDefinition().columns.map((c) => ({
+                            header: c.name,
+                            value: () => c.sampleValue ?? "",
+                            headerSize: c.colSpan,
+                        })),
+                    })),
+                };
+            case 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 EntitySerializationFormat.Csv:
+                return {
+                    fileName,
+                    contentType: "text/csv",
+                    content: Buffer.from(csvBuild(data, this.getDefinition().columns.map((c) => ({
+                        name: c.name,
+                        value: (item) => this.getColumnValue(item, c),
+                    }))), "utf-8"),
+                };
+            case EntitySerializationFormat.Xlsx:
+                return {
+                    fileName,
+                    contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                    content: Buffer.from(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 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: {
@@ -143,6 +254,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"),
@@ -153,11 +270,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"),
 };
 
@@ -166,6 +285,10 @@ const WpEntityAuthMiddleware = (entityName, props = {}) => applyDecorators(Injec
     ...props,
 }));
 
+const WpBucketProvider = (providerId) => applyDecorators(Injectable(), SetMetadata(EntityManagerSymbols.BucketProvider, {
+    providerId,
+}));
+
 const WpEntityActions = (entityName, props = {}) => applyDecorators(Injectable(), SetMetadata(EntityManagerSymbols.EntityActions, {
     entityName,
     ...props,
@@ -225,6 +348,11 @@ const WpEntitySeeder = (entityName, props = {}) => applyDecorators(Injectable(),
     ...props,
 }));
 
+const WpEntitySerializer = (entityName, props = {}) => applyDecorators(Injectable(), SetMetadata(EntityManagerSymbols.EntitySerializer, {
+    entityName,
+    ...props,
+}));
+
 const WpEventsTracker = (props = {}) => applyDecorators(Injectable(), SetMetadata(EntityManagerSymbols.EventsTracker, {
     ...props,
 }));
@@ -538,6 +666,19 @@ class EntityExistsAction {
     }
 }
 
+class EntitiesExportAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = 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;
@@ -551,6 +692,34 @@ class EntityGetAction {
     }
 }
 
+class EntitiesImportAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = 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 = 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;
@@ -709,6 +878,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;
@@ -826,6 +1072,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) {
@@ -858,6 +1113,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
@@ -910,6 +1174,9 @@ const EntityServices = {
         IEntityUpsertAction: "IEntityUpsertAction",
         IEntityDeleteAction: "IEntityDeleteAction",
         IEntityMergeAction: "IEntityMergeAction",
+        IEntitiesExportAction: "IEntitiesExportAction",
+        IEntitiesImportAction: "IEntitiesImportAction",
+        IEntitiesSampleDownloadAction: "IEntitiesSampleDownloadAction",
     },
     Authorization: {
         IEntityAuthorizationMiddleware: "IEntityAuthorizationMiddleware",
@@ -921,10 +1188,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",
@@ -962,13 +1233,14 @@ const GlobalServices = {
     Authentication: {
         IAuthenticationContextProvider: "IAuthenticationContextProvider",
     },
-    Messaging: {
-        IEmailProvider: "IEmailProvider",
-        IEmailTemplatesCollection: "IEmailTemplatesCollection",
-    },
     Pipelines: {
         IPipelineController: "IPipelineController",
     },
+    Plugins: {
+        IEmailProvider: "IEmailProvider",
+        IEmailTemplatesCollection: "IEmailTemplatesCollection",
+        IBucketProvider: "IBucketProvider",
+    },
 };
 
 class EntityServiceLocator {
@@ -1015,6 +1287,9 @@ class EntityServiceLocator {
     resolveConverter() {
         return this.services.resolveConverter(this.entityName);
     }
+    resolveSerializer() {
+        return this.services.resolveSerializer(this.entityName);
+    }
     resolveAdapter() {
         return this.services.resolveAdapter(this.entityName);
     }
@@ -1042,15 +1317,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);
     }
@@ -1078,6 +1359,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);
     }
@@ -1101,10 +1391,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);
@@ -1113,10 +1409,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);
@@ -1208,6 +1504,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,
@@ -1264,40 +1566,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);
     }
@@ -1352,6 +1644,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);
     }
@@ -1745,7 +2055,7 @@ class EntityManagerServiceCollection {
     getServiceLocator() {
         return this.resolver;
     }
-    mapCrudOperations({ queryBuilder, }) {
+    mapCrudOperations({ queryBuilder, settings, }) {
         this.mapGet();
         this.mapCount();
         this.mapExists();
@@ -1755,6 +2065,7 @@ class EntityManagerServiceCollection {
         this.mapCreate();
         this.mapUpdate();
         this.mapDelete();
+        this.mapImportExport(settings.importExport);
         return this;
     }
     mapGet() {
@@ -1783,15 +2094,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));
@@ -1809,6 +2121,10 @@ class EntityManagerServiceCollection {
         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;
@@ -1842,18 +2158,24 @@ let 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))
@@ -20391,7 +20713,7 @@ let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerI
             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 🔑");
@@ -20409,14 +20731,16 @@ let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerI
             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 = toDict(queryBuilders, (q) => q.meta.entityName);
         const converterDict = toDict(converters, (c) => c.meta.entityName);
+        const serializerDict = toDict(serializers, (s) => s.meta.entityName);
         const adapterDict = toDict(adapters, (a) => a.meta.entityName);
         const authDict = toDict(auth, (a) => a.meta.entityName);
         const sortedRepositories = lodash.exports.orderBy(repositories, (x) => x.meta.entityName);
@@ -20430,19 +20754,23 @@ let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerI
             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 ?? ""}
 ✨
       `);
@@ -20523,6 +20851,9 @@ let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerI
     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);
     }
@@ -20850,7 +21181,7 @@ AuthenticationMiddleware = __decorate([
 ], AuthenticationMiddleware);
 
 var AuthenticationModule_1;
-const ModuleData$2 = {
+const ModuleData$3 = {
     imports: [EntityManagerModule, JwtModule],
     providers: [
         AuthenticationServicesResolver,
@@ -20867,7 +21198,7 @@ let AuthenticationModule = AuthenticationModule_1 = class AuthenticationModule {
         authSettings.initialize(input);
         return {
             module: AuthenticationModule_1,
-            ...ModuleData$2,
+            ...ModuleData$3,
         };
     }
     configure(consumer) {
@@ -20880,7 +21211,7 @@ let AuthenticationModule = AuthenticationModule_1 = class AuthenticationModule {
 };
 AuthenticationModule = AuthenticationModule_1 = __decorate([
     Module({
-        ...ModuleData$2,
+        ...ModuleData$3,
     })
 ], AuthenticationModule);
 
@@ -20921,6 +21252,15 @@ MultiTenancyModule = __decorate([
     })
 ], MultiTenancyModule);
 
+const createExpressFileResponse = (res, file) => {
+    const stream = createReadStream(file.content);
+    res.set({
+        "Content-Type": file.contentType,
+        "Content-Disposition": `attachment; filename="${file.name}"`,
+    });
+    return new StreamableFile(stream);
+};
+
 class QueryBuilderBase {
     getIndexBasedPagingResult({ paging, totResults, currentPageResults, }) {
         if (!paging) {
@@ -21354,6 +21694,207 @@ class NestPipelineTemplate {
     }
 }
 
+class AwsS2BucketError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AwsS2BucketError";
+    }
+}
+
+const awsBucketSettings = new AppInMemorySettings();
+
+const createClient$1 = (settings) => new S3Client({
+    region: settings.region,
+    credentials: settings.awsAccessKeyId && settings.awsSecretAccessKey
+        ? {
+            accessKeyId: settings.awsAccessKeyId,
+            secretAccessKey: settings.awsSecretAccessKey,
+        }
+        : undefined,
+});
+let AwsS3BucketProvider = class AwsS3BucketProvider {
+    constructor() {
+        this.client = createClient$1(awsBucketSettings.value);
+    }
+    async folderList(input) {
+        try {
+            return await this.client.send(new 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 PutObjectCommand({
+                Bucket: input.bucket,
+                Key: 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 GetObjectCommand({
+                Bucket: input.bucket,
+                Key: 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 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 getSignedUrl(this.client, new 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 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 DeleteObjectCommand({
+                Bucket: input.bucket,
+                Key: input.filePath,
+            }));
+        }
+        catch (e) {
+            throw new AwsS2BucketError(`AwsS3Bucket | fileDelete | ${input.bucket} | ${input.filePath} | Error -> ${e.message}`);
+        }
+    }
+};
+AwsS3BucketProvider = __decorate([
+    WpBucketProvider("awsS3"),
+    __metadata("design:paramtypes", [])
+], AwsS3BucketProvider);
+
+var AwsBucketModule_1;
+const ModuleData$2 = {
+    providers: [AwsS3BucketProvider],
+};
+let AwsBucketModule = AwsBucketModule_1 = class AwsBucketModule {
+    static forRoot(input) {
+        awsBucketSettings.initialize(input);
+        return {
+            module: AwsBucketModule_1,
+            ...ModuleData$2,
+        };
+    }
+};
+AwsBucketModule = AwsBucketModule_1 = __decorate([
+    Module({
+        ...ModuleData$2,
+    })
+], AwsBucketModule);
+
+let 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];
+    }
+};
+InMemoryBucketProvider = __decorate([
+    WpBucketProvider("in-memory")
+], InMemoryBucketProvider);
+
 const AwsSesModuleSymbols = {
     EmailTemplate: Symbol.for("WP.PLG:AWS_SES.EMAIL_TEMPLATE"),
 };
@@ -26593,5 +27134,5 @@ InMemoryEmailProvider = __decorate([
     WpEmailProvider("in-memory")
 ], InMemoryEmailProvider);
 
-export { AUTHENTICATION_EVENTS_NAMESPACE, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationService, AwsEmailModule, AwsSesEmailTemplate, BooleanFacet, BooleanFacetItem, EmailService, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerRegistry, EntityManagerService, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntitySeeder, EventsService, InMemoryEmailProvider, InvalidCredentialsError, MemberOf, MissingEntityIdError, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestPipelineTemplate, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, NumericFacet, NumericFacetItem, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, PipelineController, PipelineErrorType, PipelineStatus, PipelineStepErrorType, PipelinesBuilder, PipelinesRunner, PlatformEvents, Public, QueryBuilderBase, ReplicationMode, Roles, SendgridEmailModule, SendgridEmailTemplate, SortDirection, StringFacet, StringFacetItem, TrackingService, UserCreationError, UserRegistrationError, WpAppInitializer, WpAwsSesEmailTemplate, WpEmailTemplate, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEventsTracker, WpPipeline, WpRolesService, WpSendgridEmailTemplate, WpUserRolesService, WpUserService, buildRolesGuard, getLocalizedText, newUuid, renderHandlebarsTemplate };
+export { AUTHENTICATION_EVENTS_NAMESPACE, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationService, AwsBucketModule, AwsEmailModule, AwsS2BucketError, AwsS3BucketProvider, AwsSesEmailTemplate, BooleanFacet, BooleanFacetItem, BucketItemType, EmailService, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerRegistry, EntityManagerService, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntitySeeder, EntitySerializationFormat, EntitySerializer, EventsService, InMemoryBucketProvider, InMemoryEmailProvider, InvalidCredentialsError, MemberOf, MissingEntityIdError, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestEntitySerializer, NestPipelineTemplate, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, NumericFacet, NumericFacetItem, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, PipelineController, PipelineErrorType, PipelineStatus, PipelineStepErrorType, PipelinesBuilder, PipelinesRunner, PlatformEvents, Public, QueryBuilderBase, ReplicationMode, Roles, SendgridEmailModule, SendgridEmailTemplate, SortDirection, StringFacet, StringFacetItem, TrackingService, UserCreationError, UserRegistrationError, WpAppInitializer, WpAwsSesEmailTemplate, WpBucketProvider, WpEmailTemplate, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEntitySerializer, WpEventsTracker, WpPipeline, WpRolesService, WpSendgridEmailTemplate, WpUserRolesService, WpUserService, buildRolesGuard, createExpressFileResponse, getLocalizedText, newUuid, renderHandlebarsTemplate };
 //# sourceMappingURL=index.js.map