@punks/backend-entity-manager 0.0.121 → 0.0.122

package/dist/cjs/index.js

@@ -627,7 +627,7 @@ class EntitiesDeleteCommand {
     }
 }
 
-const createDayPath = (d) => `${d.getFullYear()}/${(d.getMonth() + 1).toString().padStart(2, "0")}/${d
+const createDayPath$1 = (d) => `${d.getFullYear()}/${(d.getMonth() + 1).toString().padStart(2, "0")}/${d
     .getDate()
     .toString()
     .padStart(2, "0")}`;
@@ -666,7 +666,7 @@ class EntitiesExportCommand {
         });
     }
     buildAbsoluteBucketPath(relativePath) {
-        return `${this.settings.exportBucket.rootFolderPath ?? ""}/exports/${createDayPath(new Date())}/${relativePath}`;
+        return `${this.settings.exportBucket.rootFolderPath ?? ""}/exports/${createDayPath$1(new Date())}/${relativePath}`;
     }
     async getExportEntities(filters) {
         return this.services.resolveSearchQuery().execute(filters ?? {});
@@ -723,7 +723,7 @@ class EntitiesImportCommand {
         });
     }
     buildAbsoluteBucketPath(relativePath) {
-        return `${this.settings.exportBucket.rootFolderPath ?? ""}/imports/${createDayPath(new Date())}/${relativePath}`;
+        return `${this.settings.exportBucket.rootFolderPath ?? ""}/imports/${createDayPath$1(new Date())}/${relativePath}`;
     }
     get bucket() {
         return this.services.getRootServices().resolveDefaultBucketProvider();
@@ -763,7 +763,7 @@ class EntitiesSampleDownloadCommand {
         });
     }
     buildAbsoluteBucketPath(relativePath) {
-        return `${this.settings.exportBucket.rootFolderPath ?? ""}/samples/${createDayPath(new Date())}/${relativePath}`;
+        return `${this.settings.exportBucket.rootFolderPath ?? ""}/samples/${createDayPath$1(new Date())}/${relativePath}`;
     }
     get bucket() {
         return this.services.getRootServices().resolveDefaultBucketProvider();
@@ -1124,6 +1124,9 @@ const EntityServices = {
     },
 };
 const GlobalServices = {
+    Files: {
+        IFilesReferenceRepo: "IFilesReferenceRepo",
+    },
     Events: {
         IEventEmitter: "IEventEmitter",
         IEventsTracker: "IEventsTracker",
@@ -1138,6 +1141,7 @@ const GlobalServices = {
         IEmailProvider: "IEmailProvider",
         IEmailTemplatesCollection: "IEmailTemplatesCollection",
         IBucketProvider: "IBucketProvider",
+        IFileProvider: "IFileProvider",
     },
     Settings: {
         EntityManagerSettings: "EntityManagerSettings",
@@ -1327,13 +1331,31 @@ class EntitiesServiceLocator {
     }
     resolveDefaultBucketProvider() {
         const settings = this.resolveSettings();
-        return this.provider.resolveMultipleNamed(GlobalServices.Plugins.IBucketProvider, settings.defaultBuckerProvider);
+        return this.provider.resolveMultipleNamed(GlobalServices.Plugins.IBucketProvider, settings.defaultBucketProvider);
+    }
+    resolveDefaultFilesProvider() {
+        const settings = this.resolveSettings();
+        return this.provider.resolveMultipleNamed(GlobalServices.Plugins.IFileProvider, settings.defaultFilesProvider);
     }
     resolveBucketProviders() {
-        return this.provider.resolveMultiple(GlobalServices.Plugins.IBucketProvider);
+        return this.provider.resolveMultiple(GlobalServices.Plugins.IFileProvider);
     }
     registerBucketProvider(name, instance) {
         this.provider.registerMultiple(GlobalServices.Plugins.IBucketProvider, name, instance);
+        return this;
+    }
+    resolveFileProvider(providerId) {
+        return this.provider.resolveMultipleNamed(GlobalServices.Plugins.IFileProvider, providerId);
+    }
+    registerFileProvider(name, instance) {
+        this.provider.registerMultiple(GlobalServices.Plugins.IFileProvider, name, instance);
+        return this;
+    }
+    resolveFilesReferenceRepositoryProviders() {
+        return this.provider.resolve(GlobalServices.Files.IFilesReferenceRepo);
+    }
+    registerFilesReferenceRepositoryProviders(instance) {
+        this.provider.register(GlobalServices.Files.IFilesReferenceRepo, instance);
     }
     resolveEventsTracker() {
         return this.provider.resolve(GlobalServices.Events.IEventsTracker);
@@ -2219,6 +2241,8 @@ const EntityManagerSymbols = {
     EmailProvider: Symbol.for("WP:EMAIL_PROVIDER"),
     EmailTemplate: Symbol.for("WP:EMAIL_TEMPLATE"),
     BucketProvider: Symbol.for("WP:BUCKET_PROVIDER"),
+    FileProvider: Symbol.for("WP:FILE_PROVIDER"),
+    FileReferenceRepository: Symbol.for("WP:FILE_REFERENCE_REPO"),
     PipelineTemplate: Symbol.for("WP:PIPELINE_TEMPLATE"),
 };
 
@@ -20173,6 +20197,79 @@ exports.EmailService = __decorate([
     __metadata("design:paramtypes", [exports.EntityManagerRegistry])
 ], exports.EmailService);
 
+exports.FilesService = class FilesService {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async uploadFile(file) {
+        const uploadResult = await this.defaultFileProvider.uploadFile({
+            content: file.content,
+            contentType: file.contentType,
+            fileName: file.fileName,
+        });
+        const record = await this.referencesRepo.createReference({
+            providerId: uploadResult.reference,
+            reference: uploadResult.reference,
+            contentType: file.contentType,
+            fileName: file.fileName,
+            filePath: file.folderPath,
+            fileSize: file.content.length,
+            metadata: file.metadata,
+        });
+        return {
+            fileId: record.fileId,
+            providerId: record.providerId,
+            reference: record.reference,
+        };
+    }
+    async getFileContent(fileId) {
+        const ref = await this.referencesRepo.getReference(fileId);
+        const content = await this.getFileProvider(ref.providerId).downloadFile({
+            reference: ref.reference,
+        });
+        return {
+            content: content.content,
+            contentType: ref.contentType,
+            fileName: ref.fileName,
+            folderPath: ref.filePath,
+            metadata: ref.metadata,
+        };
+    }
+    async getFileDownloadUrl(fileId) {
+        const ref = await this.referencesRepo.getReference(fileId);
+        const downloadUrl = await this.getFileProvider(ref.providerId).getFileProviderDownloadUrl({
+            reference: ref.reference,
+        });
+        return {
+            contentType: ref.contentType,
+            fileName: ref.fileName,
+            downloadUrl: downloadUrl.downloadUrl,
+        };
+    }
+    getFileProvider(providerId) {
+        return this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .resolveFileProvider(providerId);
+    }
+    get defaultFileProvider() {
+        return this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .resolveDefaultFilesProvider();
+    }
+    get referencesRepo() {
+        return this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .resolveFilesReferenceRepositoryProviders();
+    }
+};
+exports.FilesService = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [exports.EntityManagerRegistry])
+], exports.FilesService);
+
 exports.EventsService = class EventsService {
     constructor(registry) {
         this.registry = registry;
@@ -20903,6 +21000,7 @@ const Services$1 = [
     exports.EntityManagerService,
     exports.EmailService,
     exports.EventsService,
+    exports.FilesService,
     exports.TrackingService,
 ];
 
@@ -21202,6 +21300,8 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
         await this.registerEmailProviders();
         await this.registerEventTrackingProviders();
         await this.registerVersioningProviders();
+        await this.registerFilesReferenceRepositoryProviders();
+        await this.registerFileProviders();
         await this.registerBucketProviders();
         await this.executeInitializers(app);
         await this.executeSeeders();
@@ -21287,6 +21387,20 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             this.logger.log(`Entity seeder initializer ${initializer.discoveredClass.name} initialized 💪`);
         }
     }
+    async registerFileProviders() {
+        const providers = await this.discoverFileProviders();
+        if (!providers.length) {
+            this.logger.warn("No file providers found ⚠️");
+            return;
+        }
+        for (const provider of providers) {
+            this.registry
+                .getContainer()
+                .getEntitiesServicesLocator()
+                .registerFileProvider(provider.meta.providerId, provider.discoveredClass.instance);
+            this.logger.log(`File provider ${provider.discoveredClass.name} registered 🚜`);
+        }
+    }
     async registerBucketProviders() {
         const providers = await this.discoverBucketProviders();
         if (!providers.length) {
@@ -21301,6 +21415,18 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             this.logger.log(`Bucket provider ${provider.discoveredClass.name} registered 🚜`);
         }
     }
+    async registerFilesReferenceRepositoryProviders() {
+        const providers = await this.discoverFilesReferenceRepositoryProviders();
+        if (!providers.length) {
+            this.logger.warn("No files repository ⚠️");
+            return;
+        }
+        this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .registerFilesReferenceRepositoryProviders(providers[0].discoveredClass.instance);
+        this.logger.log(`Files Reference Repository ${providers[0].discoveredClass.name} registered 🚜`);
+    }
     async registerEventTrackingProviders() {
         const providers = await this.discoverEventTrackingProviders();
         if (!providers.length) {
@@ -21405,6 +21531,12 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
     async discoverBucketProviders() {
         return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.BucketProvider);
     }
+    async discoverFileProviders() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.FileProvider);
+    }
+    async discoverFilesReferenceRepositoryProviders() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.FileReferenceRepository);
+    }
 };
 exports.EntityManagerInitializer = EntityManagerInitializer_1 = __decorate([
     common.Injectable(),
@@ -22452,9 +22584,70 @@ exports.AwsS3BucketProvider = __decorate([
     __metadata("design:paramtypes", [])
 ], exports.AwsS3BucketProvider);
 
+const WpFileProvider = (providerId) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.FileProvider, {
+    providerId,
+}));
+
+const createDayPath = (d) => `${d.getFullYear()}/${(d.getMonth() + 1).toString().padStart(2, "0")}/${d
+    .getDate()
+    .toString()
+    .padStart(2, "0")}`;
+let AwsS3FileProvider = class AwsS3FileProvider {
+    constructor(bucket) {
+        this.bucket = bucket;
+    }
+    getProviderId() {
+        return "awsS3";
+    }
+    async uploadFile(file) {
+        const path = this.getBucketFileUploadPath(file.fileName, new Date());
+        await this.bucket.fileUpload({
+            bucket: awsBucketSettings.value.defaultBucket,
+            filePath: path,
+            content: file.content,
+            contentType: file.contentType,
+        });
+        return {
+            reference: path,
+        };
+    }
+    async deleteFile(reference) {
+        await this.bucket.fileDelete({
+            bucket: awsBucketSettings.value.defaultBucket,
+            filePath: reference.reference,
+        });
+    }
+    async downloadFile(reference) {
+        const content = await this.bucket.fileDownload({
+            bucket: awsBucketSettings.value.defaultBucket,
+            filePath: reference.reference,
+        });
+        return {
+            content,
+        };
+    }
+    async getFileProviderDownloadUrl(reference) {
+        const url = await this.bucket.filePublicUrlCreate({
+            bucket: awsBucketSettings.value.defaultBucket,
+            expirationMinutes: awsBucketSettings.value.publicLinksExpirationMinutes,
+            filePath: reference.reference,
+        });
+        return {
+            downloadUrl: url,
+        };
+    }
+    getBucketFileUploadPath(fileName, date) {
+        return `${backendCore.ensureTailingSlash(awsBucketSettings.value.paths.filesUpload)}${createDayPath(date)}${backendCore.ensureStartSlash(backendCore.newUuid())}_${fileName}`;
+    }
+};
+AwsS3FileProvider = __decorate([
+    WpFileProvider("awsS3"),
+    __metadata("design:paramtypes", [exports.AwsS3BucketProvider])
+], AwsS3FileProvider);
+
 var AwsBucketModule_1;
 const ModuleData$2 = {
-    providers: [exports.AwsS3BucketProvider],
+    providers: [exports.AwsS3BucketProvider, AwsS3FileProvider],
 };
 exports.AwsBucketModule = AwsBucketModule_1 = class AwsBucketModule {
     static forRoot(input) {
@@ -22471,6 +22664,54 @@ exports.AwsBucketModule = AwsBucketModule_1 = __decorate([
     })
 ], exports.AwsBucketModule);
 
+let InMemoryFileProvider = class InMemoryFileProvider {
+    constructor() {
+        this.provider = new exports.InMemoryBucketProvider();
+    }
+    getProviderId() {
+        return "inMemory";
+    }
+    async uploadFile(file) {
+        const filePath = `${backendCore.newUuid()}/${file.fileName}`;
+        await this.provider.fileUpload({
+            bucket: "test",
+            content: file.content,
+            contentType: file.contentType,
+            filePath,
+        });
+        return {
+            reference: filePath,
+        };
+    }
+    async deleteFile(reference) {
+        await this.provider.fileDelete({
+            bucket: "test",
+            filePath: reference.reference,
+        });
+    }
+    async downloadFile(reference) {
+        const content = await this.provider.fileDownload({
+            bucket: "test",
+            filePath: reference.reference,
+        });
+        return {
+            content,
+        };
+    }
+    async getFileProviderDownloadUrl(reference) {
+        return {
+            downloadUrl: await this.provider.filePublicUrlCreate({
+                bucket: "test",
+                filePath: reference.reference,
+                expirationMinutes: 60,
+            }),
+        };
+    }
+};
+InMemoryFileProvider = __decorate([
+    WpFileProvider("inMemory"),
+    __metadata("design:paramtypes", [])
+], InMemoryFileProvider);
 exports.InMemoryBucketProvider = class InMemoryBucketProvider {
     constructor() {
         this.inMemoryStorage = {};