@paroicms/server/dist/index.js

The ParoiCMS server

import { eachDay, makeUrl, startCronLike } from "@paroicms/internal-server-lib";
import { setupImageProcessor } from "@paroicms/server-image-cache-engine";
import compression from "compression";
import cookieParser from "cookie-parser";
import express from "express";
import rateLimit from "express-rate-limit";
import { createRegisteredSitesFromSingle, loadRegisteredSitesFromPacks, } from "./connector/site-conf/site-conf.js";
import { readCommonSchemaLibrary } from "./connector/site-schema/common-schema-reader.js";
import { appConf, appPackage, cmsVersion, initCommonSchemaLib, initializeContext, platformAuthUrl, platformLogger, registeredSites, setAppPackage, } from "./context.js";
import { httpRedirectionMiddleware } from "./express/http-redirection-middleware.js";
import { loadPaSiteContextMiddleware, reqHandlerToExpressMiddleware, } from "./express/route-handler-wrapper.js";
import { createAdminUiGraphqlMiddleware, createMinimalSiteMiddleware, createRenderedSiteMiddleware, } from "./express/site-middleware.js";
import { createCorsMiddleware } from "./helpers/cors-middleware.js";
import { maintenanceTask, unloadAllActiveSites } from "./maintenance/maintenance-task.js";
import { handleShutdownEvents } from "./maintenance/shutdown.js";
import { createOauth2ClientMiddleware } from "./oauth/oauth-middleware.js";
import { tailReqHandler } from "./rendered-site/serve-index-page.js";
import { watchForIdleSiteContexts } from "./site-context/site-context.js";
if (process.env.NODE_ENV === "development") {
    (await import("source-map-support")).default.install();
}
export async function start(options = {}) {
    try {
        if (options.appVersion) {
            platformLogger.warn("StartOptions.appVersion is deprecated; use appPackage instead.");
            if (!options.appPackage) {
                setAppPackage({ name: "unamed", version: options.appVersion });
            }
        }
        else if (options.appPackage) {
            setAppPackage(options.appPackage);
        }
        await platformLogger.untilReady;
        const appPackageLabel = appPackage
            ? `${appPackage.name}@${appPackage.version}`
            : "(no-package)";
        platformLogger.info(`Starting ${appConf.kind} ParoiCMS ${cmsVersion}, application ${appPackageLabel}…`);
        watchForIdleSiteContexts();
        setupImageProcessor({ ...appConf.imageProcessor, logger: platformLogger });
        const regSites = appConf.kind === "multisite"
            ? await loadRegisteredSitesFromPacks(appConf, options.sitePackPlaces)
            : await createRegisteredSitesFromSingle(appConf);
        await initializeContext(regSites);
        initCommonSchemaLib(await readCommonSchemaLibrary());
        const stopCron = startCronLike(maintenanceTask, {
            shouldExecute: eachDay({ hours: 2 }),
            logger: platformLogger,
        });
        const expressApp = express();
        expressApp.use(express.json({ limit: "50mb" }));
        expressApp.use(cookieParser());
        expressApp.use(rateLimit({
            windowMs: 2_000,
            limit: 200,
            standardHeaders: true,
            legacyHeaders: false,
        }));
        expressApp.use(createCorsMiddleware());
        expressApp.use(httpRedirectionMiddleware);
        if (platformAuthUrl && appConf.googleAuth) {
            expressApp.use(await createOauth2ClientMiddleware(appConf.googleAuth.fqdn));
        }
        if (process.env.NODE_ENV === "development") {
            const { localTestingRoute } = await import("./express/local-testing-route.js");
            expressApp.post("/local-testing", localTestingRoute);
        }
        expressApp.use(loadPaSiteContextMiddleware);
        expressApp.use("/adm/backend/graphql", await createAdminUiGraphqlMiddleware());
        expressApp.use(compression());
        expressApp.use(createMinimalSiteMiddleware());
        expressApp.use(createRenderedSiteMiddleware());
        expressApp.use(reqHandlerToExpressMiddleware(tailReqHandler));
        let httpServer;
        if (appConf.hostname) {
            httpServer = expressApp.listen(appConf.port, appConf.hostname);
        }
        else {
            httpServer = expressApp.listen(appConf.port);
        }
        handleShutdownEvents({
            logger: platformLogger,
            closingTasks: [stopCron, unloadAllActiveSites, () => shutdownServer(httpServer)],
        });
        platformLogger.info(`ParoiCMS is up and running on port '${appConf.port}', it serves:${getListOfSiteUrls()
            .map(({ siteUrl, adminUiUrl }) => `\n- ${siteUrl}${adminUiUrl ? ` - admin: ${adminUiUrl}` : ""}`)
            .join("")}`);
    }
    catch (error) {
        platformLogger.error(error);
    }
}
function getListOfSiteUrls() {
    return Array.from(registeredSites.values())
        .map((regSite) => {
        return {
            siteUrl: regSite.siteUrl,
            adminUiUrl: makeUrl({
                protocol: appConf.publicProtocol,
                port: appConf.adminUiPort,
                fqdn: regSite.fqdn,
                path: "/adm",
            }),
        };
    })
        .sort((a, b) => a.siteUrl.localeCompare(b.siteUrl));
}
function shutdownServer(server) {
    return new Promise((resolve, reject) => {
        server.close((error) => {
            if (error) {
                reject(error);
            }
            else {
                resolve();
            }
        });
    });
}
//# sourceMappingURL=index.js.map