@paroicms/server/dist/context.js

The ParoiCMS server

import { createPlatformLog, humanFriendlyAlphabet, makeUrl, readOrCreateSecret, readOrCreateSecretSync, } from "@paroicms/internal-server-lib";
import { coreLanguages } from "@paroicms/public-anywhere-lib";
import { jsonTypeValidator, loadSimpleTranslatorFromDirectory, } from "@paroicms/public-server-lib";
import { esmDirName, extractPackageNameAndVersionSync } from "@paroicms/script-lib";
import { existsSync, renameSync, unlinkSync } from "node:fs";
import { dirname, join } from "node:path";
import { readAppConfSync } from "./connector/app-conf/app-conf-reader.js";
export const dbAnyLanguage = ".";
export const adminUiOwnerHandle = "adminUi";
export const packageDir = dirname(esmDirName(import.meta.url));
export const { version: cmsVersion, name: appName } = extractPackageNameAndVersionSync(packageDir);
export let appPackage;
export function setAppPackage(pkg) {
    appPackage = pkg;
}
export const appConf = readAppConfSync(jsonTypeValidator);
export const platformLogger = createPlatformLog({
    level: appConf.logLevel,
    file: appConf.logFile,
    reportMessage: true,
});
export let registeredSites;
export const httpRedirections = new Map((appConf.httpRedirections ?? []).map((item) => [item.fromFqdn, item]));
let commonSchemaLib;
export function initCommonSchemaLib(val) {
    commonSchemaLib = val;
}
export function getCommonSchemaLib() {
    if (!commonSchemaLib) {
        throw new Error("siteSchemaLib is undefined.");
    }
    return commonSchemaLib;
}
export const platformDataDir = appConf.kind === "multisite" ? appConf.platform.dataDir : appConf.singleSite.dataDir;
export const jwtSecret = readOrCreateSecretSync(join(platformDataDir, "jwt-secret.txt"));
export const jwtExpiresIn = "180d";
const oldFile = join(platformDataDir, "platform-jwt-secret.txt");
if (existsSync(oldFile)) {
    if (appConf.googleAuth)
        renameSync(oldFile, join(platformDataDir, "jwt-secret-pl.txt"));
    else
        unlinkSync(oldFile);
}
export const platformJwtSecret = appConf.googleAuth
    ? readOrCreateSecretSync(join(platformDataDir, "jwt-secret-pl.txt"))
    : undefined;
export const platformAuthUrl = appConf.googleAuth && !appConf.googleAuth.disabled
    ? makeUrl({
        protocol: appConf.publicProtocol,
        fqdn: appConf.googleAuth.fqdn,
        port: appConf.publicPort,
        path: "/auth",
    })
    : undefined;
let previewSecret;
export function getPreviewSecret() {
    if (!previewSecret)
        throw new Error("Preview secret not initialized");
    return previewSecret;
}
export let simpleI18n;
export async function initializeContext(registeredSitesVal) {
    registeredSites = registeredSitesVal;
    previewSecret = await readOrCreateSecret(join(platformDataDir, "preview-secret.txt"), {
        length: 12,
        alphabet: humanFriendlyAlphabet,
    });
    simpleI18n = await loadSimpleTranslatorFromDirectory({
        l10nDir: join(packageDir, "locales"),
        languages: coreLanguages,
        logger: platformLogger,
    });
    for (const regSite of registeredSites.values()) {
        if (!regSite.redirectWww)
            continue;
        const tokens = regSite.fqdn.split(".");
        if (tokens.length < 2 || tokens[tokens.length - 1] === "localhost")
            continue;
        const fromFqdn = tokens.length === 2
            ? `www.${regSite.fqdn}`
            : tokens.length === 3 && regSite.fqdn.startsWith("www.")
                ? regSite.fqdn.substring(4)
                : undefined;
        if (!fromFqdn || httpRedirections.has(fromFqdn))
            continue;
        httpRedirections.set(fromFqdn, {
            fromFqdn,
            to: makeUrl({
                protocol: appConf.publicProtocol,
                fqdn: regSite.fqdn,
                port: appConf.publicPort,
            }),
        });
    }
    if (httpRedirections.size > 0) {
        platformLogger.info(`HTTP 301 redirections:\n  - ${Array.from(httpRedirections.values())
            .sort((a, b) => a.fromFqdn.localeCompare(b.fromFqdn))
            .map((entry) => `${entry.fromFqdn} → ${entry.to}`)
            .join("\n  - ")}`);
    }
}
export function addRegisteredSite(regSite) {
    const { fqdn } = regSite;
    if (registeredSites.has(fqdn))
        throw new Error(`regSite for "${fqdn}" already exists.`);
    registeredSites.set(fqdn, regSite);
}
export function removeRegisteredSite(fqdn) {
    if (!registeredSites.delete(fqdn))
        throw new Error(`unknown site "${fqdn}"`);
}
//# sourceMappingURL=context.js.map