@stemy/backend 2.8.6 → 2.9.0

package/bundles/stemy-backend.umd.js

@@ -1222,25 +1222,29 @@
     exports.AssetProcessor = AssetProcessor_1 = /** @class */ (function () {
         function AssetProcessor() {
         }
-        AssetProcessor.getMimeType = function (buffer, mimeType) {
+        AssetProcessor.checkTextFileType = function (type) {
+            return type.mime.indexOf("text") >= 0 || type.mime.indexOf("xml") >= 0;
+        };
+        AssetProcessor.fixTextFileType = function (type, buffer) {
+            var text = buffer.toString("utf8");
+            if (text.indexOf("<svg") >= 0) {
+                return { ext: "svg", mime: "image/svg+xml" };
+            }
+            return type;
+        };
+        AssetProcessor.fileTypeFromBuffer = function (buffer) {
+            var _a;
             return __awaiter$u(this, void 0, void 0, function () {
-                var e_1;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            _a.trys.push([0, 2, , 3]);
-                            return [4 /*yield*/, fileType.fromBuffer(buffer)];
+                var type;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, fileType.fromBuffer(buffer)];
                         case 1:
-                            mimeType = (_a.sent()).mime;
-                            return [3 /*break*/, 3];
-                        case 2:
-                            e_1 = _a.sent();
-                            if (!mimeType) {
-                                throw "Can't determine mime type";
+                            type = ((_a = _b.sent()) !== null && _a !== void 0 ? _a : { ext: "txt", mime: "text/plain" });
+                            if (AssetProcessor_1.checkTextFileType(type)) {
+                                return [2 /*return*/, AssetProcessor_1.fixTextFileType(type, buffer)];
                             }
-                            console.log("Can't determine mime type", e_1);
-                            return [3 /*break*/, 3];
-                        case 3: return [2 /*return*/, mimeType];
+                            return [2 /*return*/, type];
                     }
                 });
             });
@@ -1266,11 +1270,11 @@
         AssetProcessor.copyImageMeta = function (buffer, metadata) {
             return __awaiter$u(this, void 0, void 0, function () {
                 var output;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0: return [4 /*yield*/, sharp$3(buffer).rotate().toBuffer({ resolveWithObject: true })];
                         case 1:
-                            output = _a.sent();
+                            output = _b.sent();
                             Object.assign(metadata, output.info);
                             return [2 /*return*/, output.data];
                     }
@@ -1287,18 +1291,18 @@
                 metadata[prop] = font[prop];
             });
         };
-        AssetProcessor.prototype.process = function (buffer, metadata, contentType) {
+        AssetProcessor.prototype.process = function (buffer, metadata, fileType) {
             return __awaiter$u(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0:
-                            if (!AssetProcessor_1.isImage(contentType)) return [3 /*break*/, 2];
+                            if (!AssetProcessor_1.isImage(fileType.mime)) return [3 /*break*/, 2];
                             return [4 /*yield*/, AssetProcessor_1.copyImageMeta(buffer, metadata)];
                         case 1:
-                            buffer = _a.sent();
-                            _a.label = 2;
+                            buffer = _b.sent();
+                            _b.label = 2;
                         case 2:
-                            if (AssetProcessor_1.isFont(contentType)) {
+                            if (AssetProcessor_1.isFont(fileType.mime)) {
                                 AssetProcessor_1.copyFontMeta(buffer, metadata);
                             }
                             return [2 /*return*/, buffer];
@@ -1797,59 +1801,32 @@
             if (contentType === void 0) { contentType = null; }
             if (metadata === void 0) { metadata = null; }
             return __awaiter$q(this, void 0, void 0, function () {
-                var extension, fileTypeStream, uploadStream, fileType$1, e_1;
-                var _this = this;
+                var uploadStream, buffer, fileType, e_1;
                 return __generator(this, function (_b) {
                     switch (_b.label) {
                         case 0:
-                            extension = null;
-                            fileTypeStream = copyStream(stream);
                             uploadStream = copyStream(stream);
-                            _b.label = 1;
+                            return [4 /*yield*/, streamToBuffer(stream)];
                         case 1:
-                            _b.trys.push([1, 3, , 4]);
-                            return [4 /*yield*/, fileType.fromStream(fileTypeStream)];
+                            buffer = _b.sent();
+                            fileType = { ext: "", mime: contentType };
+                            _b.label = 2;
                         case 2:
-                            fileType$1 = _b.sent();
-                            contentType = fileType$1.mime;
-                            extension = fileType$1.ext;
-                            return [3 /*break*/, 4];
+                            _b.trys.push([2, 4, , 5]);
+                            return [4 /*yield*/, exports.AssetProcessor.fileTypeFromBuffer(buffer)];
                         case 3:
+                            fileType = _b.sent();
+                            return [3 /*break*/, 5];
+                        case 4:
                             e_1 = _b.sent();
-                            if (!contentType) {
-                                throw "Can't determine content type";
+                            if (!fileType.mime) {
+                                throw "Can't determine mime type";
                             }
-                            console.log("Can't determine content type", e_1);
-                            return [3 /*break*/, 4];
-                        case 4:
-                            contentType = contentType.trim();
-                            extension = (extension || "").trim();
-                            metadata = Object.assign({
-                                extension: extension,
-                                downloadCount: 0,
-                                firstDownload: null,
-                                lastDownload: null
-                            }, metadata || {});
-                            metadata.filename = metadata.filename || new bson.ObjectId().toHexString();
-                            return [2 /*return*/, new Promise((function (resolve, reject) {
-                                    var uploaderStream = _this.bucket.openUploadStream(metadata.filename);
-                                    uploadStream.pipe(uploaderStream)
-                                        .on("error", function (error) {
-                                        reject(error.message || error);
-                                    })
-                                        .on("finish", function () {
-                                        var asset = new Asset(uploaderStream.id, {
-                                            filename: metadata.filename,
-                                            contentType: contentType,
-                                            metadata: metadata
-                                        }, _this.collection, _this.bucket);
-                                        asset.save().then(function () {
-                                            resolve(asset);
-                                        }, function (error) {
-                                            reject(error.message || error);
-                                        });
-                                    });
-                                }))];
+                            console.log("Can't determine mime type", e_1);
+                            return [3 /*break*/, 5];
+                        case 5:
+                            metadata = metadata || {};
+                            return [2 /*return*/, this.upload(uploadStream, fileType, metadata)];
                     }
                 });
             });
@@ -1858,16 +1835,31 @@
             if (metadata === void 0) { metadata = null; }
             if (contentType === void 0) { contentType = null; }
             return __awaiter$q(this, void 0, void 0, function () {
+                var fileType, e_2;
                 return __generator(this, function (_b) {
                     switch (_b.label) {
-                        case 0: return [4 /*yield*/, exports.AssetProcessor.getMimeType(buffer, contentType)];
+                        case 0:
+                            fileType = { ext: "", mime: contentType };
+                            _b.label = 1;
                         case 1:
-                            contentType = _b.sent();
-                            metadata = metadata || {};
-                            return [4 /*yield*/, this.assetProcessor.process(buffer, metadata, contentType)];
+                            _b.trys.push([1, 3, , 4]);
+                            return [4 /*yield*/, exports.AssetProcessor.fileTypeFromBuffer(buffer)];
                         case 2:
+                            fileType = _b.sent();
+                            return [3 /*break*/, 4];
+                        case 3:
+                            e_2 = _b.sent();
+                            if (!fileType.mime) {
+                                throw "Can't determine mime type";
+                            }
+                            console.log("Can't determine mime type", e_2);
+                            return [3 /*break*/, 4];
+                        case 4:
+                            metadata = metadata || {};
+                            return [4 /*yield*/, this.assetProcessor.process(buffer, metadata, fileType)];
+                        case 5:
                             buffer = _b.sent();
-                            return [2 /*return*/, this.write(bufferToStream(buffer), contentType, metadata)];
+                            return [2 /*return*/, this.upload(bufferToStream(buffer), fileType, metadata)];
                     }
                 });
             });
@@ -1909,7 +1901,7 @@
         Assets.prototype.findMany = function (where) {
             return __awaiter$q(this, void 0, void 0, function () {
                 var cursor, items, result, items_1, items_1_1, item;
-                var e_2, _b;
+                var e_3, _b;
                 return __generator(this, function (_c) {
                     switch (_c.label) {
                         case 0:
@@ -1926,12 +1918,12 @@
                                     result.push(new Asset(item._id, item, this.collection, this.bucket));
                                 }
                             }
-                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
                             finally {
                                 try {
                                     if (items_1_1 && !items_1_1.done && (_b = items_1.return)) _b.call(items_1);
                                 }
-                                finally { if (e_2) throw e_2.error; }
+                                finally { if (e_3) throw e_3.error; }
                             }
                             return [2 /*return*/, result];
                     }
@@ -1953,6 +1945,42 @@
                 });
             });
         };
+        Assets.prototype.upload = function (stream, fileType, metadata) {
+            return __awaiter$q(this, void 0, void 0, function () {
+                var contentType, extension;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    contentType = fileType.mime.trim();
+                    extension = (fileType.ext || "").trim();
+                    metadata = Object.assign({
+                        extension: extension,
+                        downloadCount: 0,
+                        firstDownload: null,
+                        lastDownload: null
+                    }, metadata || {});
+                    metadata.filename = metadata.filename || new bson.ObjectId().toHexString();
+                    return [2 /*return*/, new Promise((function (resolve, reject) {
+                            var uploaderStream = _this.bucket.openUploadStream(metadata.filename);
+                            stream.pipe(uploaderStream)
+                                .on("error", function (error) {
+                                reject(error.message || error);
+                            })
+                                .on("finish", function () {
+                                var asset = new Asset(uploaderStream.id, {
+                                    filename: metadata.filename,
+                                    contentType: contentType,
+                                    metadata: metadata
+                                }, _this.collection, _this.bucket);
+                                asset.save().then(function () {
+                                    resolve(asset);
+                                }, function (error) {
+                                    reject(error.message || error);
+                                });
+                            });
+                        }))];
+                });
+            });
+        };
         return Assets;
     }());
     exports.Assets = __decorate$t([
@@ -4594,6 +4622,9 @@
                             if (ext) {
                                 res.header("content-disposition", "inline; filename=" + asset.filename + "." + ext);
                             }
+                            if (asset.contentType) {
+                                res.header("content-type", asset.contentType);
+                            }
                             return [2 /*return*/, asset.download()];
                     }
                 });