Source: saltcorn-data/db/connect.js

  1. /**
  2.  * Controls Saltcorn configuration
  3.  * @type {path.PlatformPath | path}
  4.  */
  5. const path = require("path");
  6. const fs = require("fs");
  7. const envPaths = require("env-paths");
  9. const pathsNoApp = envPaths("", { suffix: "" });
  10. const pathsWithApp = envPaths("saltcorn", { suffix: "" });
  11. /**
  12.  * Default data path?
  13.  * @type {string}
  14.  */
  15. const defaultDataPath = pathsWithApp.data;
  16. const stringToJSON = (x) => (typeof x === "string" ? JSON.parse(x) : x);
  17. /**
  18.  * Get Git revision of Saltcorn source.
  19.  * Required to work:
  20.  *  - Git client installed,
  21.  *  - Local git with repo Saltcorn sources.
  22.  * @returns {null} - Return current Git commit
  23.  */
  24. const getGitRevision = () => {
  25.   let revision = null;
  26.   let options = { stdio: "pipe", cwd: __dirname };
  27.   try {
  28.     revision = require("child_process")
  29.       .execSync("git rev-parse HEAD", options)
  30.       .toString()
  31.       .trim();
  32.   } catch (error) {}
  33.   return revision;
  34. };
  35. /**
  36.  * Prepare Saltcorn connection object that controls main Saltcorn instance settings like:
  37.  * - PostgreSQL or SQLite
  38.  * - Connection to DB settings
  39.  * - Multitenant mode
  40.  * - Web Session secret
  41.  * - File store path
  42.  * - Saltcorn confuration inheritance and fixed configuration
  43.  * For all parameters and priority see the code of function.
  44.  * @param connSpec
  45.  * @returns {{sc_version: string, connectionString: *, git_commit: *, version_tag: (*|string)}|{sqlite_path}|boolean}
  46.  */
  47. const getConnectObject = (connSpec = {}) => {
  48.   const git_commit = getGitRevision();
  49.   const sc_version = require("../package.json").version;
  50.   const version_tag = git_commit || sc_version;
  51.   var connObj = { version_tag, git_commit, sc_version };
  52.   const fileCfg = getConfigFile() || {};
  54.   function setKey(k, envnm, opts = {}) {
  55.     const f = opts.transform || ((x) => x);
  56.     // Priorities:
  57.     // 1. getConnectObject argument
  58.     if (typeof connSpec[k] !== "undefined") connObj[k] = f(connSpec[k]);
  59.     // 2. Environment variables
  60.     else if (typeof process.env[envnm] !== "undefined")
  61.       connObj[k] = f(process.env[envnm]);
  62.     // 3. Config file
  63.     else if (typeof fileCfg[k] !== "undefined") connObj[k] = f(fileCfg[k]);
  64.     // 4. default
  65.     else if (typeof opts.default !== "undefined") connObj[k] = f(opts.default);
  66.   }
  68.   setKey("user", "PGUSER");
  69.   setKey("sqlite_path", "SQLITE_FILEPATH");
  70.   setKey("host", "PGHOST");
  71.   setKey("port", "PGPORT");
  72.   setKey("password", "PGPASSWORD");
  73.   setKey("database", "PGDATABASE");
  74.   setKey("session_secret", "SALTCORN_SESSION_SECRET");
  75.   setKey("multi_tenant", "SALTCORN_MULTI_TENANT", { default: false });
  76.   setKey("file_store", "SALTCORN_FILE_STORE", { default: pathsWithApp.data });
  77.   setKey("default_schema", "SALTCORN_DEFAULT_SCHEMA", { default: "public" });
  78.   setKey("fixed_configuration", "SALTCORN_FIXED_CONFIGURATION", {
  79.     default: {},
  80.     transform: stringToJSON,
  81.   });
  82.   setKey("inherit_configuration", "SALTCORN_INHERIT_CONFIGURATION", {
  83.     default: [],
  84.     transform: stringToJSON,
  85.   });
  87.   if (process.env.DATABASE_URL) {
  88.     delete connObj[user];
  89.     delete connObj[password];
  90.     delete connObj[database];
  91.     delete connObj[sqlite_path];
  92.     return { ...connObj, connectionString: process.env.DATABASE_URL };
  93.   } else if (
  94.     connObj.sqlite_path ||
  95.     (connObj.user && connObj.password && connObj.database)
  96.   ) {
  97.     return connObj;
  98.   } else {
  99.     return false;
  100.   }
  101. };
  102. /**
  103.  * Path to Config directory
  104.  * @type {string}
  105.  */
  106. const configFileDir = pathsNoApp.config;
  107. /**
  108.  * Path to config file .saltcorn
  109.  * @type {string}
  110.  */
  111. const configFilePath = path.join(configFileDir, ".saltcorn");
  112. /**
  113.  * Reads Saltcorn configuration file
  114.  * @returns {boolean|any} - Returns JSON presentation of Saltcorn confuration file. Returns false in case of Exception.
  115.  */
  116. const getConfigFile = () => {
  117.   try {
  118.     let rawdata = fs.readFileSync(configFilePath);
  119.     return JSON.parse(rawdata);
  120.   } catch (e) {
  121.     return false;
  122.   }
  123. };
  124. /**
  125.  * Check that Saltcorn configured to use SQLite as database
  126.  * @param connObj - connectin object
  127.  * @returns {boolean} - Returns true if Saltcorn configured to use SQLite as database
  128.  */
  129. const is_sqlite = (connObj) => {
  130.   if (connObj.connectionString)
  131.     return connObj.connectionString.startsWith("sqlite");
  133.   return !!connObj.sqlite_path;
  134. };
  136. module.exports = {
  137.   getConnectObject,
  138.   getConfigFile,
  139.   configFileDir,
  140.   configFilePath,
  141.   is_sqlite,
  142.   defaultDataPath,
  143. };