datasquirel/package-shared/utils/backend/names/grab-dir-names.ts

import { DATASQUIREL_LoggedInUser, UserType } from "../../../types";
import path from "path";

type Param = {
    user?: DATASQUIREL_LoggedInUser | UserType;
    userId?: string | number | null;
    appDir?: string;
    dataDir?: string;
};
export default function grabDirNames(param?: Param) {
    const appDir = param?.appDir || process.env.DSQL_APP_DIR;
    const DATA_DIR = param?.dataDir || process.env.DSQL_DATA_DIR || "/data";

    const finalUserId = param?.user?.id || param?.userId;

    if (!appDir)
        throw new Error("Please provide the `DSQL_APP_DIR` env variable.");

    if (!DATA_DIR)
        throw new Error("Please provide the `DATA_DIR` env variable.");

    const STATIC_ROOT = path.join(DATA_DIR, "static");
    const publicImagesDir = path.join(STATIC_ROOT, `images`);

    const publicDir = path.join(appDir, "public");
    const publicSSLDir = path.join(publicDir, "documents", "ssl");
    const appSSLDir = path.join(appDir, "ssl");
    const mainSSLDir = path.join(DATA_DIR, "ssl");

    const privateDataDir = path.join(DATA_DIR, "private");

    /**
     * # DB Dir names
     * @description Database related Directories
     */
    const mainDbDataDir = path.join(DATA_DIR, "db");
    const mainDbGrastateDatFile = path.join(mainDbDataDir, "grastate.dat");
    const replica1DbDataDir = path.join(DATA_DIR, "replica-1");

    const mariadbMainConfigDir = path.join(DATA_DIR, "db-config", "main");
    const mariadbReplicaConfigDir = path.join(DATA_DIR, "db-config", "replica");
    const maxscaleConfigDir = path.join(DATA_DIR, "db-config", "maxscale");

    const mariadbMainConfigFile = path.join(
        mariadbMainConfigDir,
        "default.cnf"
    );
    const mariadbReplicaConfigFile = path.join(
        mariadbReplicaConfigDir,
        "default.cnf"
    );
    const galeraConfigFile = path.join(mariadbMainConfigDir, "galera.cnf");
    const galeraReplicaConfigFile = path.join(
        mariadbReplicaConfigDir,
        "galera.cnf"
    );
    const maxscaleConfigFile = path.join(maxscaleConfigDir, "maxscale.cnf");

    /**
     * # Schema Dir names
     * @description
     */
    const oldSchemasDir = path.join(appDir, "jsonData", "dbSchemas");
    const appSchemaJSONFile = path.join(oldSchemasDir, "1.json");
    const tempDirName = ".tmp";

    const appConfigDir = path.join(appDir, "jsonData", "config");
    const appConfigJSONFile = path.join(appConfigDir, "app-config.json");

    if (!privateDataDir)
        throw new Error(
            "Please provide the `DSQL_DB_SCHEMA_DIR` env variable."
        );

    const pakageSharedDir = path.join(appDir, `package-shared`);

    const mainDbTypeDefFile = path.join(pakageSharedDir, `types/dsql.ts`);
    const mainShemaJSONFilePath = path.join(oldSchemasDir, `main.json`);
    const defaultTableFieldsJSONFilePath = path.join(
        pakageSharedDir,
        `data/defaultFields.json`
    );

    const usersSchemaDir = path.join(privateDataDir, `users`);
    const targetUserPrivateDir = finalUserId
        ? path.join(usersSchemaDir, `user-${finalUserId}`)
        : undefined;
    const userTempSQLFilePath = targetUserPrivateDir
        ? path.join(targetUserPrivateDir, `tmp.sql`)
        : undefined;
    const userMainShemaJSONFilePath = targetUserPrivateDir
        ? path.join(targetUserPrivateDir, `main.json`)
        : undefined;

    const userConfigJSONFilePath = targetUserPrivateDir
        ? path.join(targetUserPrivateDir, `config.json`)
        : undefined;

    const userSchemaMainJSONFilePath = targetUserPrivateDir
        ? path.join(targetUserPrivateDir, `main.json`)
        : undefined;
    const userPrivateMediaDir = targetUserPrivateDir
        ? path.join(targetUserPrivateDir, `media`)
        : undefined;
    const userPrivateExportsDir = targetUserPrivateDir
        ? path.join(targetUserPrivateDir, `export`)
        : undefined;
    const userPrivateSQLExportsDir = userPrivateExportsDir
        ? path.join(userPrivateExportsDir, `sql`)
        : undefined;
    const userPrivateTempSQLExportsDir = userPrivateSQLExportsDir
        ? path.join(userPrivateSQLExportsDir, tempDirName)
        : undefined;
    const userPrivateTempJSONSchemaFilePath = userPrivateTempSQLExportsDir
        ? path.join(userPrivateTempSQLExportsDir, `schema.json`)
        : undefined;
    const userPrivateDbExportZipFileName = `db-export.zip`;
    const userPrivateDbExportZipFilePath = userPrivateSQLExportsDir
        ? path.join(userPrivateSQLExportsDir, userPrivateDbExportZipFileName)
        : undefined;

    const userPublicMediaDir = finalUserId
        ? path.join(publicImagesDir, `user-images/user-${finalUserId}`)
        : undefined;

    const userPrivateDbImportZipFileName = `db-export.zip`;
    const userPrivateDbImportZipFilePath = userPrivateSQLExportsDir
        ? path.join(userPrivateSQLExportsDir, userPrivateDbImportZipFileName)
        : undefined;

    const dbNginxLoadBalancerConfigFile = path.join(
        appDir,
        "docker/services/mariadb/load-balancer/config/template/nginx.conf"
    );

    let dockerComposeFile = path.join(appDir, "docker-compose.yml");
    let dockerComposeFileAlt = path.join(appDir, "docker-compose.yaml");
    const testDockerComposeFile = path.join(appDir, "test.docker-compose.yml");
    const testDockerComposeFileAlt = path.join(
        appDir,
        "test.docker-compose.yaml"
    );
    const dbDockerComposeFile = path.join(appDir, "db.docker-compose.yml");
    const dbDockerComposeFileAlt = path.join(appDir, "db.docker-compose.yaml");
    const extraDockerComposeFile = path.join(
        appDir,
        "extra.docker-compose.yml"
    );
    const extraDockerComposeFileAlt = path.join(
        appDir,
        "extra.docker-compose.yaml"
    );

    const siteSetupFile = path.join(appDir, "site-setup.json");

    const envFile = path.join(appDir, ".env");
    const testEnvFile = path.join(appDir, "test.env");

    /**
     * # Backup Dir names
     * @description
     */
    const mainBackupDir = path.join(DATA_DIR, "backups");
    const userBackupDir = targetUserPrivateDir
        ? path.join(targetUserPrivateDir, `backups`)
        : undefined;

    const sqlBackupDirName = `sql`;
    const schemasBackupDirName = `schema`;

    return {
        appDir,
        privateDataDir,
        oldSchemasDir,
        userConfigJSONFilePath,
        mainShemaJSONFilePath,
        mainDbTypeDefFile,
        tempDirName,
        defaultTableFieldsJSONFilePath,
        usersSchemaDir,
        targetUserPrivateDir,
        userSchemaMainJSONFilePath,
        userPrivateMediaDir,
        userPrivateExportsDir,
        userPrivateSQLExportsDir,
        userPrivateTempSQLExportsDir,
        userPrivateTempJSONSchemaFilePath,
        userPrivateDbExportZipFileName,
        userPrivateDbExportZipFilePath,
        userPrivateDbImportZipFileName,
        userPrivateDbImportZipFilePath,
        dbNginxLoadBalancerConfigFile,
        dockerComposeFile,
        dockerComposeFileAlt,
        testDockerComposeFile,
        testDockerComposeFileAlt,
        extraDockerComposeFile,
        extraDockerComposeFileAlt,
        siteSetupFile,
        envFile,
        testEnvFile,
        userPublicMediaDir,
        userTempSQLFilePath,
        STATIC_ROOT,
        appConfigJSONFile,
        appConfigDir,
        mariadbMainConfigDir,
        mariadbMainConfigFile,
        maxscaleConfigDir,
        mariadbReplicaConfigDir,
        DATA_DIR,
        publicDir,
        publicSSLDir,
        appSSLDir,
        maxscaleConfigFile,
        mariadbReplicaConfigFile,
        mainSSLDir,
        mainDbDataDir,
        replica1DbDataDir,
        galeraConfigFile,
        galeraReplicaConfigFile,
        dbDockerComposeFile,
        dbDockerComposeFileAlt,
        mainDbGrastateDatFile,
        appSchemaJSONFile,
        mainBackupDir,
        userBackupDir,
        sqlBackupDirName,
        schemasBackupDirName,
        userMainShemaJSONFilePath,
    };
}