@stemy/backend 2.8.6 → 2.9.0

package/fesm2015/stemy-backend.js

@@ -18,7 +18,7 @@ import { getValue as getValue$1, setValue } from 'mongoose/lib/utils';
 import { PassThrough, Readable } from 'stream';
 import { ObjectId } from 'bson';
 import fontKit_ from 'fontkit';
-import { fromBuffer, fromStream } from 'file-type';
+import { fromBuffer } from 'file-type';
 import sharp_ from 'sharp';
 import axios from 'axios';
 import { GridFSBucket } from 'mongodb';
@@ -774,18 +774,24 @@ const fontProps = [
     "xHeight", "numGlyphs", "characterSet", "availableFeatures"
 ];
 let AssetProcessor = AssetProcessor_1 = class AssetProcessor {
-    static getMimeType(buffer, mimeType) {
+    static checkTextFileType(type) {
+        return type.mime.indexOf("text") >= 0 || type.mime.indexOf("xml") >= 0;
+    }
+    static fixTextFileType(type, buffer) {
+        const text = buffer.toString("utf8");
+        if (text.indexOf("<svg") >= 0) {
+            return { ext: "svg", mime: "image/svg+xml" };
+        }
+        return type;
+    }
+    static fileTypeFromBuffer(buffer) {
+        var _a;
         return __awaiter$u(this, void 0, void 0, function* () {
-            try {
-                mimeType = (yield fromBuffer(buffer)).mime;
-            }
-            catch (e) {
-                if (!mimeType) {
-                    throw `Can't determine mime type`;
-                }
-                console.log(`Can't determine mime type`, e);
+            const type = ((_a = yield fromBuffer(buffer)) !== null && _a !== void 0 ? _a : { ext: "txt", mime: "text/plain" });
+            if (AssetProcessor_1.checkTextFileType(type)) {
+                return AssetProcessor_1.fixTextFileType(type, buffer);
             }
-            return mimeType;
+            return type;
         });
     }
     static extractFontFormat(font) {
@@ -823,12 +829,12 @@ let AssetProcessor = AssetProcessor_1 = class AssetProcessor {
             metadata[prop] = font[prop];
         });
     }
-    process(buffer, metadata, contentType) {
+    process(buffer, metadata, fileType) {
         return __awaiter$u(this, void 0, void 0, function* () {
-            if (AssetProcessor_1.isImage(contentType)) {
+            if (AssetProcessor_1.isImage(fileType.mime)) {
                 buffer = yield AssetProcessor_1.copyImageMeta(buffer, metadata);
             }
-            if (AssetProcessor_1.isFont(contentType)) {
+            if (AssetProcessor_1.isFont(fileType.mime)) {
                 AssetProcessor_1.copyFontMeta(buffer, metadata);
             }
             return buffer;
@@ -1171,56 +1177,37 @@ let Assets = class Assets {
     }
     write(stream, contentType = null, metadata = null) {
         return __awaiter$q(this, void 0, void 0, function* () {
-            let extension = null;
-            const fileTypeStream = copyStream(stream);
             const uploadStream = copyStream(stream);
+            const buffer = yield streamToBuffer(stream);
+            let fileType = { ext: "", mime: contentType };
             try {
-                const fileType = yield fromStream(fileTypeStream);
-                contentType = fileType.mime;
-                extension = fileType.ext;
+                fileType = yield AssetProcessor.fileTypeFromBuffer(buffer);
             }
             catch (e) {
-                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);
+                console.log(`Can't determine mime type`, e);
             }
-            contentType = contentType.trim();
-            extension = (extension || "").trim();
-            metadata = Object.assign({
-                extension,
-                downloadCount: 0,
-                firstDownload: null,
-                lastDownload: null
-            }, metadata || {});
-            metadata.filename = metadata.filename || new ObjectId().toHexString();
-            return new Promise(((resolve, reject) => {
-                const uploaderStream = this.bucket.openUploadStream(metadata.filename);
-                uploadStream.pipe(uploaderStream)
-                    .on("error", error => {
-                    reject(error.message || error);
-                })
-                    .on("finish", () => {
-                    const asset = new Asset(uploaderStream.id, {
-                        filename: metadata.filename,
-                        contentType,
-                        metadata
-                    }, this.collection, this.bucket);
-                    asset.save().then(() => {
-                        resolve(asset);
-                    }, error => {
-                        reject(error.message || error);
-                    });
-                });
-            }));
+            metadata = metadata || {};
+            return this.upload(uploadStream, fileType, metadata);
         });
     }
     writeBuffer(buffer, metadata = null, contentType = null) {
         return __awaiter$q(this, void 0, void 0, function* () {
-            contentType = yield AssetProcessor.getMimeType(buffer, contentType);
+            let fileType = { ext: "", mime: contentType };
+            try {
+                fileType = yield AssetProcessor.fileTypeFromBuffer(buffer);
+            }
+            catch (e) {
+                if (!fileType.mime) {
+                    throw `Can't determine mime type`;
+                }
+                console.log(`Can't determine mime type`, e);
+            }
             metadata = metadata || {};
-            buffer = yield this.assetProcessor.process(buffer, metadata, contentType);
-            return this.write(bufferToStream(buffer), contentType, metadata);
+            buffer = yield this.assetProcessor.process(buffer, metadata, fileType);
+            return this.upload(bufferToStream(buffer), fileType, metadata);
         });
     }
     writeUrl(url, metadata = null) {
@@ -1261,6 +1248,38 @@ let Assets = class Assets {
             return asset.unlink();
         });
     }
+    upload(stream, fileType, metadata) {
+        return __awaiter$q(this, void 0, void 0, function* () {
+            const contentType = fileType.mime.trim();
+            const extension = (fileType.ext || "").trim();
+            metadata = Object.assign({
+                extension,
+                downloadCount: 0,
+                firstDownload: null,
+                lastDownload: null
+            }, metadata || {});
+            metadata.filename = metadata.filename || new ObjectId().toHexString();
+            return new Promise(((resolve, reject) => {
+                const uploaderStream = this.bucket.openUploadStream(metadata.filename);
+                stream.pipe(uploaderStream)
+                    .on("error", error => {
+                    reject(error.message || error);
+                })
+                    .on("finish", () => {
+                    const asset = new Asset(uploaderStream.id, {
+                        filename: metadata.filename,
+                        contentType,
+                        metadata
+                    }, this.collection, this.bucket);
+                    asset.save().then(() => {
+                        resolve(asset);
+                    }, error => {
+                        reject(error.message || error);
+                    });
+                });
+            }));
+        });
+    }
 };
 Assets = __decorate$t([
     injectable(),
@@ -2893,6 +2912,9 @@ let AssetsController = class AssetsController {
             if (ext) {
                 res.header("content-disposition", `inline; filename=${asset.filename}.${ext}`);
             }
+            if (asset.contentType) {
+                res.header("content-type", asset.contentType);
+            }
             return asset.download();
         });
     }