@paroicms/server/dist/connector/site-conf/site-conf.js

The ParoiCMS server

import { makeUrl } from "@paroicms/internal-server-lib";
import { generateSlug } from "@paroicms/public-anywhere-lib";
import { type } from "arktype";
import { readdir, readFile, stat } from "node:fs/promises";
import { join, resolve } from "node:path";
const StringOrUndefinedAT = type("string|undefined");
export async function createRegisteredSitesFromSingle(appConf) {
    const { publicProtocol, publicPort } = appConf;
    const { siteDir, dataDir, cacheDir, backupDir, fqdn, redirectWww, trusted, allowUnsafeLogin } = appConf.singleSite;
    const siteUrl = makeUrl({
        protocol: publicProtocol,
        fqdn,
        port: publicPort,
    });
    const version = await getPackageVersionIfExists(siteDir);
    const regSite = Object.freeze({
        fqdn,
        siteName: fqdn,
        version,
        siteDir,
        dataDir,
        cacheDir,
        backupDir,
        siteUrl,
        redirectWww,
        trusted: trusted !== false,
        allowUnsafeLogin: allowUnsafeLogin === true,
    });
    const result = new Map();
    result.set(regSite.fqdn, regSite);
    return result;
}
export async function loadRegisteredSitesFromPacks(appConf, sitePackPlaces) {
    const result = new Map();
    for (const pack of appConf.sitePacks) {
        const packRegSites = pack.sitesDir
            ? await readRegisteredSitesFromDirectory(pack.sitesDir, pack, appConf)
            : createRegisteredSitesFromDependency(pack, appConf, sitePackPlaces?.[pack.packName]);
        for (const regSite of packRegSites) {
            if (result.has(regSite.fqdn))
                throw new Error(`duplicated site '${regSite.fqdn}'`);
            result.set(regSite.fqdn, regSite);
        }
    }
    return result;
}
export async function createNewRegisteredSite(options, appConf) {
    const { siteDir, domain, version, packName } = options;
    const pack = appConf.sitePacks.find((p) => p.packName === packName);
    if (!pack)
        throw new Error(`pack "${packName}" not found`);
    return makeRegisteredSite({ domain, siteDir, version }, pack, appConf);
}
async function readRegisteredSitesFromDirectory(sitesDir, pack, appConf) {
    const entries = await readdir(sitesDir);
    const result = [];
    for (const entry of entries) {
        if (entry === "index" || entry.startsWith("."))
            continue;
        const st = await stat(resolve(sitesDir, entry));
        if (!st.isDirectory())
            continue;
        const siteDir = resolve(sitesDir, entry);
        const version = await getPackageVersionIfExists(siteDir);
        result.push(makeRegisteredSite({ domain: entry, siteDir, version }, pack, appConf));
    }
    return result;
}
async function getPackageVersionIfExists(dir) {
    try {
        const content = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
        return StringOrUndefinedAT.assert(content.version);
    }
    catch {
    }
}
function createRegisteredSitesFromDependency(pack, appConf, sitePlaces) {
    if (!sitePlaces)
        throw new Error(`missing 'sitesDir' or a place for pack '${pack.packName}'`);
    return sitePlaces.map((place) => makeRegisteredSite(place, pack, appConf));
}
function makeRegisteredSite(place, pack, appConf) {
    const { publicProtocol, publicPort } = appConf;
    const { domain, siteDir, version } = place;
    const fqdn = pack.serveOn === "fqdn" ? domain : `${toSubDomain(domain)}.${pack.parentDomain}`;
    const siteUrl = makeUrl({
        protocol: publicProtocol,
        fqdn,
        port: publicPort,
    });
    const dataDir = resolve(pack.dataDir, domain);
    const cacheDir = resolve(pack.cacheDir, domain);
    const backupDir = resolve(pack.backupDir, domain);
    return Object.freeze({
        fqdn,
        siteName: `${pack.packName}:${domain}`,
        version,
        siteDir,
        dataDir,
        cacheDir,
        backupDir,
        siteUrl,
        redirectWww: pack.redirectWww,
        trusted: pack.trusted !== false,
        allowUnsafeLogin: pack.allowUnsafeLogin === true,
    });
}
function toSubDomain(dirName) {
    let result = dirName;
    if (result.startsWith("www.")) {
        result = result.substring(4);
    }
    const extIndex = result.lastIndexOf(".");
    if (extIndex !== -1) {
        result = result.substring(0, extIndex);
    }
    return generateSlug(result).replaceAll(".", "-");
}
//# sourceMappingURL=site-conf.js.map