@furystack/rest-service/esm/static-server-manager.js

Repository implementation for FuryStack

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { Injectable, Injected } from '@furystack/inject';
import { createReadStream } from 'fs';
import { access, stat } from 'fs/promises';
import { getMimeForFile } from './mime-types.js';
import { join, normalize, sep } from 'path';
import { ServerManager } from './server-manager.js';
let StaticServerManager = class StaticServerManager {
    async sendFile({ fullPath, headers, res, }) {
        const { size } = await stat(fullPath);
        await access(fullPath);
        const head = {
            ...headers,
            'Content-Length': size,
            'Content-Type': getMimeForFile(fullPath),
        };
        Object.entries(head).map(([key, value]) => res.setHeader(key, value));
        await new Promise((resolve, reject) => createReadStream(fullPath, { autoClose: true }).once('finish', resolve).once('error', reject).pipe(res));
    }
    shouldExec = (baseUrl) => ({ req }) => req.url &&
        req.method?.toUpperCase() === 'GET' &&
        (req.url === baseUrl || req.url.startsWith(baseUrl[baseUrl.length - 1] === '/' ? baseUrl : `${baseUrl}/`))
        ? true
        : false;
    onRequest = ({ path, baseUrl, fallback, headers, }) => {
        return async ({ req, res }) => {
            const filePath = req.url.substring(baseUrl.length - 1).replaceAll('/', sep);
            const fullPath = normalize(join(path, filePath));
            try {
                await this.sendFile({ fullPath, res, headers });
            }
            catch (error) {
                if (fallback) {
                    await this.sendFile({ fullPath: normalize(join(path, fallback)), res, headers });
                }
                else {
                    res.writeHead(404, { 'Content-Type': 'text/plain' });
                    res.end('Not found');
                }
            }
        };
    };
    async addStaticSite(options) {
        const server = await this.serverManager.getOrCreate({ hostName: options.hostName, port: options.port });
        server.apis.push({
            shouldExec: this.shouldExec(options.baseUrl),
            onRequest: this.onRequest({ ...options }),
        });
    }
};
__decorate([
    Injected(ServerManager),
    __metadata("design:type", ServerManager)
], StaticServerManager.prototype, "serverManager", void 0);
StaticServerManager = __decorate([
    Injectable({ lifetime: 'singleton' })
], StaticServerManager);
export { StaticServerManager };
//# sourceMappingURL=static-server-manager.js.map