@hed-hog/core 0.0.387 → 0.0.393

package/dist/file/file.service.js

@@ -11,6 +11,14 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var _a;
 var FileService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileService = void 0;
@@ -23,12 +31,23 @@ const api_prisma_1 = require("@hed-hog/api-prisma");
 const common_1 = require("@nestjs/common");
 const jwt_1 = require("@nestjs/jwt");
 const fs_1 = require("fs");
+const os_1 = require("os");
 const path_1 = require("path");
 const promises_1 = require("stream/promises");
+const uuid_1 = require("uuid");
 const integration_profile_utils_1 = require("../integration-profile/integration-profile.utils");
 const setting_service_1 = require("../setting/setting.service");
 const image_optimization_service_1 = require("./image-optimization.service");
+const abstract_provider_1 = require("./provider/abstract.provider");
 const provider_factory_1 = require("./provider/provider.factory");
+/**
+ * Resolver o provider custa 3 queries (setting + integration_profile, que ainda decifra o
+ * config, + file_provider) e reconstrói o client de storage a cada arquivo. Em upload em
+ * massa — segmentos HLS, frames, pacotes SCORM — isso vira milhares de round-trips em
+ * rajadas paralelas e é o que estoura o pool de conexões durante a conversão de vídeo.
+ * A janela curta mantém a troca de perfil de storage praticamente imediata.
+ */
+const PROVIDER_CACHE_TTL_MS = Math.max(0, Number((_a = process.env.FILE_PROVIDER_CACHE_TTL_MS) !== null && _a !== void 0 ? _a : 30000));
 let FileService = FileService_1 = class FileService {
     resolveProviderPath(file) {
         // Supports legacy basename-only values while prioritizing full provider keys.
@@ -58,6 +77,8 @@ let FileService = FileService_1 = class FileService {
         this.imageOptimizationService = imageOptimizationService;
         this.logger = new common_1.Logger(FileService_1.name);
         this.mimetypes = {};
+        this.cachedProvider = null;
+        this.providerResolution = null;
     }
     async onModuleInit() {
         try {
@@ -70,6 +91,22 @@ let FileService = FileService_1 = class FileService {
         }
     }
     async getProvider() {
+        const cached = this.cachedProvider;
+        if (cached && cached.expiresAt > Date.now()) {
+            this.providerId = cached.providerId;
+            return cached.provider;
+        }
+        // Uploads paralelos (lotes de segmentos HLS) chegam aqui juntos; sem esta deduplicação
+        // cada um dispara o mesmo conjunto de queries em vez de aproveitar a primeira resolução.
+        if (this.providerResolution) {
+            return this.providerResolution;
+        }
+        this.providerResolution = this.resolveProvider().finally(() => {
+            this.providerResolution = null;
+        });
+        return this.providerResolution;
+    }
+    async resolveProvider() {
         var _a;
         const settings = await this.settingService.getSettingValues(['file-storage-profile-id']);
         const profileSlug = String((_a = settings['file-storage-profile-id']) !== null && _a !== void 0 ? _a : '').trim();
@@ -101,7 +138,15 @@ let FileService = FileService_1 = class FileService {
             throw new common_1.BadRequestException(`Provider ${fileProviderSlug} not found.`);
         }
         this.providerId = providerData.id;
-        return await provider_factory_1.ProviderFactory.create(enumProvider, config, this.jwtService);
+        const provider = await provider_factory_1.ProviderFactory.create(enumProvider, config, this.jwtService);
+        if (PROVIDER_CACHE_TTL_MS > 0) {
+            this.cachedProvider = {
+                provider,
+                providerId: providerData.id,
+                expiresAt: Date.now() + PROVIDER_CACHE_TTL_MS,
+            };
+        }
+        return provider;
     }
     async getMimeType(mimetype) {
         if (!mimetype) {
@@ -306,6 +351,38 @@ let FileService = FileService_1 = class FileService {
             buffer,
         };
     }
+    /**
+     * Renderiza um cartão social 1200x630 (JPEG) a partir de arquivos do acervo.
+     *
+     * Devolve `null` quando não há arquivo utilizável — quem chama deve responder
+     * 404 e deixar o consumidor cair na imagem padrão da marca, nunca 500: do
+     * outro lado costuma haver um robô de link preview.
+     */
+    async renderShareCard(options) {
+        const load = async (fileId) => {
+            if (!fileId)
+                return null;
+            try {
+                const { buffer } = await this.getBuffer(fileId);
+                return buffer;
+            }
+            catch (_a) {
+                return null;
+            }
+        };
+        const [background, overlay] = await Promise.all([
+            load(options.backgroundFileId),
+            load(options.overlayFileId),
+        ]);
+        if (!background && !overlay) {
+            return null;
+        }
+        const buffer = await this.imageOptimizationService.composeShareCard(background, overlay, { background: options.background });
+        if (!buffer) {
+            return null;
+        }
+        return { buffer, contentType: 'image/jpeg' };
+    }
     async getLocalFile(fileId, res) {
         const { buffer, file } = await this.getBuffer(fileId);
         res.set({
@@ -314,7 +391,13 @@ let FileService = FileService_1 = class FileService {
         });
         res.send(buffer);
     }
-    async upload(destination, fileBuffer, resize) {
+    async upload(destination, fileBuffer, resize, 
+    // Escape hatch para chamadores INTERNOS que já validaram por conta própria —
+    // o mesmo par de flags que `uploadFromPath` sempre teve. O FileController não
+    // repassa este argumento, então não há como acioná-lo por HTTP.
+    // `isPrivate` tira o arquivo das rotas que servem por id sem autenticação.
+    options) {
+        var _a;
         if (!fileBuffer) {
             throw new common_1.BadRequestException(`No file provided`);
         }
@@ -322,10 +405,11 @@ let FileService = FileService_1 = class FileService {
             throw new common_1.BadRequestException(`No destination provided`);
         }
         const provider = await this.getProvider();
-        if (!(await this.acceptMimetypes(fileBuffer.mimetype))) {
+        if (!(options === null || options === void 0 ? void 0 : options.skipMimeValidation) &&
+            !(await this.acceptMimetypes(fileBuffer.mimetype))) {
             throw new common_1.BadRequestException(`Invalid file type: ${fileBuffer.mimetype}`);
         }
-        if (!(await this.maxFileSize(fileBuffer.size))) {
+        if (!(options === null || options === void 0 ? void 0 : options.skipSizeValidation) && !(await this.maxFileSize(fileBuffer.size))) {
             throw new common_1.BadRequestException(`File too large: ${fileBuffer.size} bytes`);
         }
         const normalizedFilename = this.normalizeUploadedFilename(fileBuffer.originalname);
@@ -341,12 +425,13 @@ let FileService = FileService_1 = class FileService {
                 location: destination,
                 mimetype_id: await this.getMimeType(optimized.mimetype),
                 size: optimized.buffer.length,
+                is_private: (_a = options === null || options === void 0 ? void 0 : options.isPrivate) !== null && _a !== void 0 ? _a : false,
             },
         });
         return file;
     }
     async uploadFromPath(destination, filePath, metadata) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         if (!filePath) {
             throw new common_1.BadRequestException(`No file path provided`);
         }
@@ -387,16 +472,20 @@ let FileService = FileService_1 = class FileService {
                     location: destination,
                     mimetype_id: await this.getMimeType(mimetype),
                     size,
+                    is_private: (_d = metadata === null || metadata === void 0 ? void 0 : metadata.isPrivate) !== null && _d !== void 0 ? _d : false,
                 },
             });
         }
         // Read buffer to allow image optimization regardless of provider support
         const rawBuffer = await fs_1.promises.readFile(filePath);
-        const optimized = await this.imageOptimizationService.optimizeBuffer(rawBuffer, mimetype, originalname);
+        const optimized = await this.imageOptimizationService.optimizeBuffer(rawBuffer, mimetype, originalname, {
+            maxWidth: (_e = metadata === null || metadata === void 0 ? void 0 : metadata.resize) === null || _e === void 0 ? void 0 : _e.maxWidth,
+            maxHeight: (_f = metadata === null || metadata === void 0 ? void 0 : metadata.resize) === null || _f === void 0 ? void 0 : _f.maxHeight,
+        });
         const url = await provider.upload(destination, {
             fieldname: 'file',
             originalname: optimized.originalname,
-            encoding: (_d = metadata === null || metadata === void 0 ? void 0 : metadata.encoding) !== null && _d !== void 0 ? _d : '7bit',
+            encoding: (_g = metadata === null || metadata === void 0 ? void 0 : metadata.encoding) !== null && _g !== void 0 ? _g : '7bit',
             mimetype: optimized.mimetype,
             size: optimized.buffer.length,
             destination: '',
@@ -412,6 +501,7 @@ let FileService = FileService_1 = class FileService {
                 location: destination,
                 mimetype_id: await this.getMimeType(optimized.mimetype),
                 size: optimized.buffer.length,
+                is_private: (_h = metadata === null || metadata === void 0 ? void 0 : metadata.isPrivate) !== null && _h !== void 0 ? _h : false,
             },
         });
         return file;
@@ -530,9 +620,108 @@ let FileService = FileService_1 = class FileService {
         }
         return file;
     }
+    /**
+     * Creates an independent copy of a stored file: new bytes in storage + a new `file` row.
+     *
+     * Unlike sharing a `file_id`, the result survives the original being deleted — which is what
+     * "duplicate files" means when copying course content between courses.
+     *
+     * `filename` and `destination` default to the source's, so a caller that only wants
+     * independent bytes gets them without thinking about paths. Passing `destination` matters for
+     * artifacts addressed by their location (HLS manifests and segments).
+     *
+     * The bytes are copied server-side when the active provider supports it; otherwise — and when
+     * the provider-side copy fails, e.g. an object above S3's 5GB CopyObject cap — they are
+     * streamed through a temp file, never buffered in RAM. Mime/size validation is skipped: the
+     * source already passed it at upload time.
+     */
+    async duplicate(fileId, options) {
+        var _a, _b, _c, _d;
+        const source = await this.prismaService.file.findUnique({
+            where: { id: fileId },
+            include: { file_mimetype: true },
+        });
+        if (!source) {
+            throw new common_1.NotFoundException(`File not found: ${fileId}`);
+        }
+        const destination = (_a = options === null || options === void 0 ? void 0 : options.destination) !== null && _a !== void 0 ? _a : source.location;
+        const filename = (_b = options === null || options === void 0 ? void 0 : options.filename) !== null && _b !== void 0 ? _b : source.filename;
+        const sourcePath = this.resolveProviderPath(source);
+        const provider = await this.getProvider();
+        let storedFilename = null;
+        if ((0, abstract_provider_1.supportsServerSideCopy)(provider)) {
+            try {
+                storedFilename = await provider.copy(sourcePath, destination, filename);
+            }
+            catch (error) {
+                this.logger.warn(`Server-side copy failed for file ${fileId}, falling back to streaming: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (storedFilename === null) {
+            const tempPath = (0, path_1.join)((0, os_1.tmpdir)(), `hedhog-file-copy-${(0, uuid_1.v4)()}`);
+            try {
+                await this.downloadToPath(fileId, tempPath);
+                storedFilename = await provider.uploadFromPath(destination, tempPath, {
+                    filename,
+                    mimetype: (_c = source.file_mimetype) === null || _c === void 0 ? void 0 : _c.name,
+                });
+            }
+            finally {
+                await fs_1.promises.unlink(tempPath).catch(() => undefined);
+            }
+        }
+        return this.prismaService.file.create({
+            data: {
+                filename,
+                path: storedFilename,
+                provider_id: this.providerId,
+                location: destination,
+                mimetype_id: source.mimetype_id,
+                size: (_d = source.size) !== null && _d !== void 0 ? _d : 0,
+            },
+        });
+    }
     async readStream(filepath) {
         return (await this.getProvider()).readStream(filepath);
     }
+    /**
+     * Confere se os bytes de um `file` estão mesmo no storage, devolvendo o tamanho
+     * relatado pelo provider ao lado do tamanho declarado no banco.
+     *
+     * Existe para quem precisa **provar** que a cópia sobreviveu antes de apagar o
+     * original em outro lugar: o registro em banco sozinho não é prova, porque é
+     * gravado depois do upload e nada reconcilia os dois se o insert falhar no meio
+     * — o blob fica órfão ou a linha aponta para o vazio, e ninguém percebe até
+     * alguém tentar ler.
+     *
+     * Não lança quando o objeto está ausente: devolve `storedSize: null`, para o
+     * chamador decidir o que fazer com a divergência.
+     */
+    async statStoredFile(fileId) {
+        var _a, _b, _c;
+        if (!fileId) {
+            throw new common_1.BadRequestException(`No file ID provided`);
+        }
+        const file = await this.prismaService.file.findUnique({
+            where: { id: fileId },
+        });
+        if (!file) {
+            throw new common_1.NotFoundException(`File not found: ${fileId}`);
+        }
+        const provider = await this.getProvider();
+        try {
+            const metadata = await provider.metaData(this.resolveProviderPath(file));
+            return {
+                storedSize: (_a = this.getFileSizeFromMetadata(metadata)) !== null && _a !== void 0 ? _a : null,
+                declaredSize: Number((_b = file.size) !== null && _b !== void 0 ? _b : 0),
+            };
+        }
+        catch (_d) {
+            // Qualquer falha de leitura de metadado — ausente, sem permissão, provider
+            // fora do ar — é tratada como "não deu para provar", nunca como sucesso.
+            return { storedSize: null, declaredSize: Number((_c = file.size) !== null && _c !== void 0 ? _c : 0) };
+        }
+    }
     getFileSizeFromMetadata(metadata) {
         if (!metadata) {
             return undefined;
@@ -618,13 +807,25 @@ let FileService = FileService_1 = class FileService {
      * Resolves the file record and its storage metadata (mimetype + size) without
      * opening a read stream — so callers can answer a conditional 304 cheaply.
      */
+    /**
+     * Metadados para servir um arquivo POR ID.
+     *
+     * Só os dois handlers anônimos passam por aqui (`serveFileById` e
+     * `serveImageById`), e é por isso que a checagem de `is_private` mora neste
+     * ponto e não em cada um: id de arquivo é sequencial, então servir por id é uma
+     * porta enumerável. O caminho por token (`download`) não passa por aqui, então
+     * um arquivo privado continua acessível ao admin via
+     * `PUT /file/open/:id` -> token -> `GET /file/open/:token`.
+     */
     async resolveFileMeta(locale, id) {
         var _a;
         const file = await this.prismaService.file.findFirst({
             where: { id },
             include: { file_mimetype: true },
         });
-        if (!file) {
+        // Privado responde igual a inexistente: confirmar que o id existe já
+        // entregaria metade do que a enumeração procura.
+        if (!file || file.is_private) {
             throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('file.download.not_found', locale, `Not found: ${id}`));
         }
         const provider = await this.getProvider();
@@ -701,13 +902,60 @@ let FileService = FileService_1 = class FileService {
         }
         return mimetype !== null && mimetype !== void 0 ? mimetype : 'application/octet-stream';
     }
+    /**
+     * Widths this endpoint is willing to render. An allowlist is required, not a
+     * range check: the endpoint is `@Public()`, and an arbitrary width means
+     * arbitrary CPU and an unbounded number of cache entries per file.
+     */
+    async getAllowedImageWidths() {
+        var _a;
+        const DEFAULT_WIDTHS = [64, 128, 320, 400, 480, 640, 896, 1200];
+        const settings = await this.settingService.getSettingValues('image-resize-allowed-widths');
+        try {
+            const parsed = JSON.parse((_a = settings['image-resize-allowed-widths']) !== null && _a !== void 0 ? _a : '');
+            const widths = (Array.isArray(parsed) ? parsed : [])
+                .map((w) => Math.round(Number(w)))
+                .filter((w) => Number.isFinite(w) && w > 0);
+            return widths.length ? widths : DEFAULT_WIDTHS;
+        }
+        catch (_b) {
+            return DEFAULT_WIDTHS;
+        }
+    }
+    /**
+     * Resolves the requested variant against the allowlist. Anything unknown or
+     * out of the list collapses to "no variant", which serves the original bytes
+     * instead of failing — a stale `?w=` in cached HTML must not 500.
+     */
+    async resolveImageVariant(variant) {
+        const width = Math.round(Number(variant === null || variant === void 0 ? void 0 : variant.width) || 0);
+        if (width <= 0)
+            return null;
+        const allowed = await this.getAllowedImageWidths();
+        if (!allowed.includes(width))
+            return null;
+        const format = ['webp', 'jpeg', 'png', 'avif'].includes(String(variant === null || variant === void 0 ? void 0 : variant.format))
+            ? String(variant === null || variant === void 0 ? void 0 : variant.format)
+            : undefined;
+        const rawQuality = Math.round(Number(variant === null || variant === void 0 ? void 0 : variant.quality) || 0);
+        const quality = rawQuality >= 50 && rawQuality <= 95 ? rawQuality : 80;
+        return { width, format, quality };
+    }
+    /** Absolute path of the on-disk cache entry for a rendered variant. */
+    imageVariantCachePath(id, size, width, format, quality) {
+        return (0, path_1.join)((0, os_1.tmpdir)(), 'hedhog-image-variants', `${id}-${size !== null && size !== void 0 ? size : 0}-w${width}-${format}-q${quality}`);
+    }
     /**
      * Serves an image by id with strong, immutable HTTP caching. The content of a
      * given fileId never changes (a new upload yields a new id), so the ETag is
      * derived from id+size instead of hashing the buffer, keeping it streaming.
+     *
+     * With a `variant` (`?w=`), the bytes are resized before being sent and the
+     * ETag carries the variant parameters — otherwise a conditional request for
+     * one width would get a 304 while holding the bytes of another.
      */
-    async serveImageById(locale, id, ifNoneMatch, res) {
-        var _a, _b;
+    async serveImageById(locale, id, ifNoneMatch, res, variant) {
+        var _a, _b, _c;
         const { provider, providerPath, size, mimetype, filename } = await this.resolveFileMeta(locale, id);
         // Many legacy/imported files store a generic mimetype (application/octet-stream).
         // Since this endpoint serves images referenced by <img> tags, infer the
@@ -720,16 +968,92 @@ let FileService = FileService_1 = class FileService {
         if (!contentType.startsWith('image/') && !isGenericBinary) {
             throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('file.download.not_found', locale, `Not an image: ${id}`));
         }
-        const etag = `"img-${id}-${size !== null && size !== void 0 ? size : 0}"`;
+        const resolved = await this.resolveImageVariant(variant);
+        const variantSuffix = resolved
+            ? `-w${resolved.width}-${(_c = resolved.format) !== null && _c !== void 0 ? _c : 'auto'}-q${resolved.quality}`
+            : '';
+        const etag = `"img-${id}-${size !== null && size !== void 0 ? size : 0}${variantSuffix}"`;
         if (ifNoneMatch && ifNoneMatch === etag) {
             res.status(304).end();
             return;
         }
         const ttl = await this.getCacheTtl('image-cache-ttl-seconds', 2592000);
-        this.setInlineHeaders(res, filename, contentType, size, `public, max-age=${ttl}, immutable`, etag);
+        const cacheControl = `public, max-age=${ttl}, immutable`;
+        if (resolved) {
+            const rendered = await this.renderImageVariant(provider, providerPath, contentType, id, size, resolved);
+            // A null render (unsupported format, sharp failure) falls through to the
+            // original bytes below rather than erroring the request.
+            if (rendered) {
+                const ext = rendered.mimetype.replace('image/', '');
+                this.setInlineHeaders(res, `${(0, path_1.basename)(filename, (0, path_1.extname)(filename))}.${ext === 'jpeg' ? 'jpg' : ext}`, rendered.mimetype, rendered.buffer.length, cacheControl, etag);
+                res.end(rendered.buffer);
+                return;
+            }
+        }
+        this.setInlineHeaders(res, filename, contentType, size, cacheControl, etag);
         const stream = await provider.readStream(providerPath);
         stream.pipe(res);
     }
+    /**
+     * Produces (and memoizes on disk) a resized variant of a stored image.
+     * The cache key includes the file size, so re-uploading under the same id —
+     * which the storage layer does not normally do — cannot serve stale bytes.
+     */
+    async renderImageVariant(provider, providerPath, contentType, id, size, variant) {
+        var _a, e_1, _b, _c;
+        var _d;
+        const format = (_d = variant.format) !== null && _d !== void 0 ? _d : (contentType === 'image/png'
+            ? 'png'
+            : contentType === 'image/webp'
+                ? 'webp'
+                : contentType === 'image/avif'
+                    ? 'avif'
+                    : 'jpeg');
+        const cachePath = this.imageVariantCachePath(id, size, variant.width, format, variant.quality);
+        try {
+            const cached = await fs_1.promises.readFile(cachePath);
+            return { buffer: cached, mimetype: `image/${format}` };
+        }
+        catch (_e) {
+            // Cache miss is the normal path on a cold pod; fall through and render.
+        }
+        try {
+            const stream = await provider.readStream(providerPath);
+            const chunks = [];
+            try {
+                for (var _f = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = await stream_1.next(), _a = stream_1_1.done, !_a; _f = true) {
+                    _c = stream_1_1.value;
+                    _f = false;
+                    const chunk = _c;
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = stream_1.return)) await _b.call(stream_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            const original = Buffer.concat(chunks);
+            const rendered = await this.imageOptimizationService.resizeBuffer(original, contentType, { width: variant.width, format: variant.format, quality: variant.quality });
+            if (!rendered)
+                return null;
+            try {
+                await fs_1.promises.mkdir((0, path_1.dirname)(cachePath), { recursive: true });
+                await fs_1.promises.writeFile(cachePath, rendered.buffer);
+            }
+            catch (err) {
+                // A read-only or full tmpdir must not break serving the image.
+                this.logger.warn(`Could not cache image variant ${cachePath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return { buffer: rendered.buffer, mimetype: rendered.mimetype };
+        }
+        catch (err) {
+            this.logger.warn(`Could not render image variant for file ${id}: ${err instanceof Error ? err.message : String(err)}. Serving the original.`);
+            return null;
+        }
+    }
     /**
      * Serves any file by id with configurable HTTP caching (not immutable, shorter
      * TTL than images). Used by the generic open endpoint's numeric-id branch.
@@ -1029,6 +1353,33 @@ let FileService = FileService_1 = class FileService {
             expiresIn: `${Math.max(1, Number(expires) || 3600)}s`,
         });
     }
+    /**
+     * Base pública para URLs de arquivo devolvidas ao navegador.
+     *
+     * Não dá para derivar do `Host` da requisição: apps que falam com a API por
+     * proxy interno (o class, via rewrite `/api` do Next) fazem o Nest enxergar o
+     * Service do cluster, e a URL sai como `http://hub-api:3100/...` — inútil no
+     * navegador. O setting `api-url` é a URL pública canônica da API no repo; o
+     * `Host` fica só como fallback para ambientes sem o setting configurado.
+     */
+    async resolvePublicBaseUrl(req) {
+        let configured = '';
+        try {
+            const settings = await this.settingService.getSettingValues([
+                'api-url',
+                'url',
+            ]);
+            const value = (settings === null || settings === void 0 ? void 0 : settings['api-url']) || (settings === null || settings === void 0 ? void 0 : settings['url']);
+            configured = typeof value === 'string' ? value.trim() : '';
+        }
+        catch (_a) {
+            configured = '';
+        }
+        if (/^https?:\/\/.+/i.test(configured)) {
+            return configured.replace(/\/+$/, '');
+        }
+        return `${req.protocol}://${req.get('host')}`;
+    }
 };
 exports.FileService = FileService;
 exports.FileService = FileService = FileService_1 = __decorate([