manifest 4.7.1 → 4.8.1

package/dist/manifest/src/app.module.js

@@ -19,6 +19,7 @@ const typeorm_1 = require("@nestjs/typeorm");
 const auth_module_1 = require("./auth/auth.module");
 const database_1 = __importDefault(require("./config/database"));
 const general_1 = __importDefault(require("./config/general"));
+const storage_1 = __importDefault(require("./config/storage"));
 const paths_1 = __importDefault(require("./config/paths"));
 const crud_module_1 = require("./crud/crud.module");
 const entity_module_1 = require("./entity/entity.module");
@@ -60,7 +61,7 @@ exports.AppModule = AppModule = __decorate([
             config_1.ConfigModule.forRoot({
                 isGlobal: true,
                 envFilePath: ['.env', '.env.contribution'],
-                load: [general_1.default, database_1.default, paths_1.default]
+                load: [general_1.default, database_1.default, paths_1.default, storage_1.default]
             }),
             typeorm_1.TypeOrmModule.forRootAsync({
                 imports: [config_1.ConfigModule, entity_module_1.EntityModule, manifest_module_1.ManifestModule],

package/dist/manifest/src/config/database.js

@@ -17,7 +17,12 @@ exports.default = () => {
                 password: process.env.DB_PASSWORD || 'postgres',
                 database: process.env.DB_DATABASE || 'manifest',
                 dropSchema: process.env.DB_DROP_SCHEMA === 'true' || false,
-                ssl: process.env.DB_SSL === 'true' || false,
+                ssl: process.env.DB_SSL === 'true'
+                    ? {
+                        rejectUnauthorized: false,
+                        requestCert: true
+                    }
+                    : false,
                 synchronize: true
             }
         }

package/dist/manifest/src/config/storage.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => {
+    return {
+        storage: {
+            s3Bucket: process.env.S3_BUCKET,
+            s3Endpoint: process.env.S3_ENDPOINT,
+            s3Region: process.env.S3_REGION,
+            s3AccessKeyId: process.env.S3_ACCESS_KEY_ID,
+            s3SecretAccessKey: process.env.S3_SECRET_ACCESS_KEY
+        }
+    };
+};

package/dist/manifest/src/handler/handler.service.js

@@ -65,12 +65,15 @@ let HandlerService = class HandlerService {
         if (!fs_1.default.existsSync(handlerPath)) {
             throw new common_1.HttpException('Handler not found', 404);
         }
-        const module = await Promise.resolve(`${handlerPath}`).then(s => __importStar(require(s)));
+        const module = await this.dynamicImport(handlerPath);
         if (typeof module.default !== 'function') {
             throw new common_1.HttpException('Handler is invalid', 404);
         }
         return module.default;
     }
+    async dynamicImport(path) {
+        return Promise.resolve(`${path}`).then(s => __importStar(require(s)));
+    }
 };
 exports.HandlerService = HandlerService;
 exports.HandlerService = HandlerService = __decorate([

package/dist/manifest/src/seed/services/seeder.service.js

@@ -105,9 +105,9 @@ let SeederService = class SeederService {
                 if (entityManifest.authenticable) {
                     entityManifest.properties.push(...constants_1.AUTHENTICABLE_PROPS);
                 }
-                entityManifest.properties.forEach((propertyManifest) => {
-                    newRecord[propertyManifest.name] = this.seedProperty(propertyManifest, entityManifest);
-                });
+                for (const propertyManifest of entityManifest.properties) {
+                    newRecord[propertyManifest.name] = await this.seedProperty(propertyManifest, entityManifest);
+                }
                 entityManifest.relationships
                     .filter((relationship) => relationship.type === 'many-to-one')
                     .forEach((relationManifest) => {
@@ -140,7 +140,7 @@ let SeederService = class SeederService {
         await Promise.all(manyToManyPromises);
         return;
     }
-    seedProperty(propertyManifest, entityManifest) {
+    async seedProperty(propertyManifest, entityManifest) {
         switch (propertyManifest.type) {
             case types_1.PropType.String:
                 return faker_1.faker.commerce.product();
@@ -189,7 +189,7 @@ let SeederService = class SeederService {
                 if (this.seededFiles[`${entityManifest.slug}.${propertyManifest.name}`]) {
                     return this.seededFiles[`${entityManifest.slug}.${propertyManifest.name}`];
                 }
-                const filePath = this.seedFile(entityManifest.slug, propertyManifest.name);
+                const filePath = await this.seedFile(entityManifest.slug, propertyManifest.name);
                 this.seededFiles[`${entityManifest.slug}.${propertyManifest.name}`] =
                     filePath;
                 return filePath;
@@ -197,7 +197,7 @@ let SeederService = class SeederService {
                 if (this.seededFiles[`${entityManifest.slug}.${propertyManifest.name}`]) {
                     return this.seededFiles[`${entityManifest.slug}.${propertyManifest.name}`];
                 }
-                const images = this.seedImage(entityManifest.slug, propertyManifest.name, propertyManifest.options?.['sizes']);
+                const images = await this.seedImage(entityManifest.slug, propertyManifest.name, propertyManifest.options?.['sizes']);
                 this.seededFiles[`${entityManifest.slug}.${propertyManifest.name}`] =
                     images;
                 return images;
@@ -209,9 +209,9 @@ let SeederService = class SeederService {
         admin.password = (0, crypto_js_1.SHA3)(constants_1.DEFAULT_ADMIN_CREDENTIALS.password).toString();
         await repository.save(admin);
     }
-    seedFile(entity, property) {
+    async seedFile(entity, property) {
         const dummyFileContent = fs.readFileSync(path.join(__dirname, '..', '..', '..', '..', 'assets', constants_1.DUMMY_FILE_NAME));
-        const filePath = this.storageService.store(entity, property, {
+        const filePath = await this.storageService.store(entity, property, {
             originalname: constants_1.DUMMY_FILE_NAME,
             buffer: dummyFileContent
         });

package/dist/manifest/src/storage/services/storage.service.js

@@ -50,49 +50,94 @@ const common_1 = require("@nestjs/common");
 const common_2 = require("../../../../common/src");
 const constants_1 = require("../../constants");
 const fs = __importStar(require("fs"));
-const mkdirp = __importStar(require("mkdirp"));
 const sharp_1 = __importDefault(require("sharp"));
+const mkdirp = __importStar(require("mkdirp"));
 const uniqid_1 = __importDefault(require("uniqid"));
 const slugify_1 = __importDefault(require("slugify"));
 const config_1 = require("@nestjs/config");
+const client_s3_1 = require("@aws-sdk/client-s3");
 let StorageService = class StorageService {
     constructor(configService) {
         this.configService = configService;
+        this.isS3Enabled = false;
+        this.isS3Enabled = !!this.configService.get('storage.s3Bucket');
+        this.s3Endpoint = this.configService.get('storage.s3Endpoint');
+        this.s3Bucket = this.configService.get('storage.s3Bucket');
+        this.s3Region = this.configService.get('storage.s3Region');
+        this.s3AccessKeyId = this.configService.get('storage.s3AccessKeyId');
+        this.s3SecretAccessKey = this.configService.get('storage.s3SecretAccessKey');
+        this.s3provider = this.s3Endpoint?.includes('amazon')
+            ? 'aws'
+            : this.s3Endpoint?.includes('digitalocean')
+                ? 'digitalocean'
+                : 'other';
+        if (this.isS3Enabled) {
+            this.s3Client = new client_s3_1.S3Client({
+                region: this.s3Region,
+                endpoint: this.s3Endpoint,
+                credentials: {
+                    accessKeyId: this.s3AccessKeyId,
+                    secretAccessKey: this.s3SecretAccessKey
+                },
+                forcePathStyle: false
+            });
+        }
     }
     store(entity, property, file) {
         const folder = this.createUploadFolder(entity, property);
         const filePath = `${folder}/${(0, uniqid_1.default)()}-${(0, slugify_1.default)(file.originalname)}`;
-        fs.writeFileSync(`${this.configService.get('paths').publicFolder}/${constants_1.STORAGE_PATH}/${filePath}`, file.buffer);
-        return this.prependStorageUrl(filePath);
+        if (this.isS3Enabled) {
+            return this.uploadToS3(filePath, file.buffer);
+        }
+        else {
+            fs.writeFileSync(`${this.configService.get('paths.publicFolder')}/${constants_1.STORAGE_PATH}/${filePath}`, file.buffer);
+            return Promise.resolve(this.prependStorageUrl(filePath));
+        }
     }
-    storeImage(entity, property, image, imageSizes) {
+    async storeImage(entity, property, image, imageSizes) {
         const folder = this.createUploadFolder(entity, property);
         const uniqueName = (0, uniqid_1.default)();
         const imagePaths = {};
-        Object.keys(imageSizes || constants_1.DEFAULT_IMAGE_SIZES).forEach((sizeName) => {
+        for (const sizeName in imageSizes || constants_1.DEFAULT_IMAGE_SIZES) {
             const imagePath = `${folder}/${uniqueName}-${sizeName}.jpg`;
-            (0, sharp_1.default)(image.buffer)
+            const resizedImage = await (0, sharp_1.default)(image.buffer)
                 .jpeg({ quality: 80 })
                 .resize(imageSizes[sizeName].width, imageSizes[sizeName].height, {
                 fit: imageSizes[sizeName].fit
             })
-                .toFile(`${this.configService.get('paths').publicFolder}/${constants_1.STORAGE_PATH}/${imagePath}`, () => {
-                return imagePath;
-            });
-            imagePaths[sizeName] = this.prependStorageUrl(imagePath);
-        });
+                .toBuffer();
+            if (this.isS3Enabled) {
+                imagePaths[sizeName] = await this.uploadToS3(imagePath, resizedImage);
+            }
+            else {
+                fs.writeFileSync(`${this.configService.get('paths.publicFolder')}/${constants_1.STORAGE_PATH}/${imagePath}`, resizedImage);
+                imagePaths[sizeName] = this.prependStorageUrl(imagePath);
+            }
+        }
         return imagePaths;
     }
     createUploadFolder(entity, property) {
         const dateString = new Date().toLocaleString('en-us', { month: 'short' }) +
             new Date().getFullYear();
         const folder = `${(0, common_2.kebabize)(entity)}/${(0, common_2.kebabize)(property)}/${dateString}`;
-        mkdirp.sync(`${this.configService.get('paths').publicFolder}/${constants_1.STORAGE_PATH}/${folder}`);
+        if (!this.isS3Enabled) {
+            mkdirp.sync(`${this.configService.get('paths.publicFolder')}/${constants_1.STORAGE_PATH}/${folder}`);
+        }
         return folder;
     }
     prependStorageUrl(value) {
         return `${this.configService.get('baseUrl')}/${constants_1.STORAGE_PATH}/${value}`;
     }
+    async uploadToS3(key, buffer) {
+        await this.s3Client.send(new client_s3_1.PutObjectCommand({
+            Bucket: this.s3Bucket,
+            Key: `${constants_1.STORAGE_PATH}/${key}`,
+            Body: buffer,
+            ChecksumAlgorithm: undefined,
+            ACL: this.s3provider === 'digitalocean' ? 'public-read' : undefined
+        }));
+        return `${this.s3Endpoint}/${this.s3Bucket}/${constants_1.STORAGE_PATH}/${key}`;
+    }
 };
 exports.StorageService = StorageService;
 exports.StorageService = StorageService = __decorate([

package/dist/manifest/src/upload/controllers/upload.controller.js

@@ -20,9 +20,9 @@ let UploadController = class UploadController {
     constructor(uploadService) {
         this.uploadService = uploadService;
     }
-    uploadFile(file, entity, property) {
+    async uploadFile(file, entity, property) {
         return {
-            path: this.uploadService.storeFile({
+            path: await this.uploadService.storeFile({
                 file,
                 entity,
                 property
@@ -46,7 +46,7 @@ __decorate([
     __param(2, (0, common_1.Body)('property')),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, String, String]),
-    __metadata("design:returntype", Object)
+    __metadata("design:returntype", Promise)
 ], UploadController.prototype, "uploadFile", null);
 __decorate([
     (0, common_1.Post)('/image'),
@@ -56,7 +56,7 @@ __decorate([
     __param(2, (0, common_1.Body)('property')),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, String, String]),
-    __metadata("design:returntype", Object)
+    __metadata("design:returntype", Promise)
 ], UploadController.prototype, "uploadImage", null);
 exports.UploadController = UploadController = __decorate([
     (0, common_1.Controller)('upload'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "manifest",
-  "version": "4.7.1",
+  "version": "4.8.1",
   "description": "The 1-file micro-backend",
   "author": "Manifest",
   "license": "MIT",
@@ -59,6 +59,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.744.0",
     "@faker-js/faker": "^8.4.1",
     "@nestjs/common": "^10.4.8",
     "@nestjs/config": "^3.3.0",